1 files changed, 70 insertions, 41 deletions

diff --git a/src/webview/spellchecker.js b/src/webview/spellchecker.js
index a504a4039..b0192b7ef 100644
--- a/src/webview/spellchecker.js
+++ b/src/webview/spellchecker.js
@@ -1,63 +1,92 @@
-import { SpellCheckHandler } from 'electron-spellchecker';
+import { webFrame } from 'electron';
+import fs from 'fs';
+import path from 'path';
+import { SpellCheckerProvider } from 'electron-hunspell';
 
-import { isMac } from '../environment';
+import { DICTIONARY_PATH } from '../config';
 
-export default class Spellchecker {
-  isInitialized = false;
-  handler = null;
-  initRetries = 0;
-  DOMCheckInterval = null;
+const debug = require('debug')('Franz:spellchecker');
 
-  get inputs() {
-    return document.querySelectorAll('input[type="text"], [contenteditable="true"], textarea');
-  }
+let provider;
+let currentDict;
+let _isEnabled = false;
 
-  initialize() {
-    this.handler = new SpellCheckHandler();
+async function loadDictionaries() {
+  const rawList = fs.readdirSync(DICTIONARY_PATH);
 
-    if (!isMac) {
-      this.attach();
-    } else {
-      this.isInitialized = true;
-    }
+  const dicts = rawList.filter(item => !item.startsWith('.') && fs.lstatSync(path.join(DICTIONARY_PATH, item)).isDirectory());
+
+  debug('Found dictionaries', dicts);
+
+  for (let i = 0; i < dicts.length; i += 1) {
+    const fileLocation = `${DICTIONARY_PATH}/${dicts[i]}/${dicts[i]}`;
+    debug('Trying to load', fileLocation);
+    // eslint-disable-next-line
+    await provider.loadDictionary(dicts[i], `${fileLocation}.dic`, `${fileLocation}.aff`);
   }
+}
+
+export async function switchDict(locale) {
+  try {
+    debug('Trying to load dictionary', locale);
 
-  attach() {
-    let initFailed = false;
+    if (!provider.availableDictionaries.includes(locale)) {
+      console.warn('Dict not available', locale);
 
-    if (this.initRetries > 3) {
-      console.error('Could not initialize spellchecker');
       return;
     }
 
-    try {
-      this.handler.attachToInput();
-      this.handler.switchLanguage(navigator.language);
-    } catch (err) {
-      initFailed = true;
-      this.initRetries = +1;
-      setTimeout(() => { this.attach(); console.warn('Spellchecker init failed, trying again in 5s'); }, 5000);
+    if (!provider) {
+      console.warn('SpellcheckProvider not initialized');
+
+      return;
     }
 
-    if (!initFailed) {
-      this.isInitialized = true;
+    if (locale === currentDict) {
+      console.warn('Dictionary is already used', currentDict);
+
+      return;
     }
-  }
 
-  toggleSpellchecker(enable = false) {
-    this.inputs.forEach((input) => {
-      input.setAttribute('spellcheck', enable);
-    });
+    provider.switchDictionary(locale);
 
-    this.intervalHandler(enable);
+    debug('Switched dictionary to', locale);
+
+    currentDict = locale;
+    _isEnabled = true;
+  } catch (err) {
+    console.error(err);
   }
+}
 
-  intervalHandler(enable) {
-    clearInterval(this.DOMCheckInterval);
+export default async function initialize(languageCode = 'en-us') {
+  try {
+    provider = new SpellCheckerProvider();
+    const locale = languageCode.toLowerCase();
 
-    if (enable) {
-      this.DOMCheckInterval = setInterval(() => this.toggleSpellchecker(enable), 30000);
-    }
+    debug('Init spellchecker');
+    await provider.initialize();
+    await loadDictionaries();
+
+    debug('Available spellchecker dictionaries', provider.availableDictionaries);
+
+    switchDict(locale);
+
+    return provider;
+  } catch (err) {
+    console.error(err);
+    return false;
   }
 }
 
+export function isEnabled() {
+  return _isEnabled;
+}
+
+export function disable() {
+  if (isEnabled()) {
+    webFrame.setSpellCheckProvider(currentDict, true, { spellCheck: () => true });
+    _isEnabled = false;
+    currentDict = null;
+  }
+}