WIP

ext/bg/js/options.js

@@ -17,64 +17,104 @@
  */
 
 
-function versionOptions(options) {
+function optionsSetDefaults(options) {
+    const defaults = {
+        general: {
+            autoStart:     true,
+            audioPlayback: true,
+            softKatakana:  true,
+            groupResults:  true,
+            showAdvanced:  false
+        },
+
+        scanning: {
+            requireShift: true,
+            selectText:   true,
+            delay:        15,
+            length:       10
+        },
+
+        dictionaries: {},
+
+        anki: {
+            enable:      false,
+            tags:        ['yomichan'],
+            sentenceExt: 200,
+            terms:       {deck: '', model: '', fields: {}},
+            kanji:       {deck: '', model: '', fields: {}},
+        }
+    };
+
+    const combine = (target, source) => {
+        for (const key in source) {
+            if (!(key in target)) {
+                target[key] = source[key];
+            }
+        }
+    };
+
+    combine(options,            defaults);
+    combine(options.general,    defaults.general);
+    combine(options.scanning,   defaults.scanning);
+    combine(options.anki,       defaults.anki);
+    combine(options.anki.terms, defaults.anki.terms);
+    combine(options.anki.kanji, defaults.anki.kanji);
+
+    return options;
+}
+
+
+function optionsVersion(options) {
+    const copy = (targetDict, targetKey, sourceDict, sourceKey) => {
+        targetDict[targetKey] = sourceDict[sourceKey] || targetDict[targetKey];
+    };
+
     const version = options.version || 0;
     const fixups = [
-        () => {}
+        () => {
+            optionsSetDefaults(options);
+
+            copy(options.general, 'autoStart',     options, 'activateOnStartup');
+            copy(options.general, 'audioPlayback', options, 'enableAudioPlayback');
+            copy(options.general, 'softKatakana',  options, 'enableSoftKatakanaSearch');
+            copy(options.general, 'groupResults',  options, 'goupTermResults');
+            copy(options.general, 'showAdvanced',  options, 'showAdvancedOptions');
+
+            copy(options.scanning, 'requireShift', options, 'holdShiftToScan');
+            copy(options.scanning, 'selectText',   options, 'selectMatchedText');
+            copy(options.scanning, 'delay',        options, 'scanDelay');
+            copy(options.scanning, 'length',       options, 'scanLength');
+
+            options.anki.enable = options.ankiMethod === 'ankiconnect';
+
+            copy(options.anki,       'tags',        options, 'ankiCardTags');
+            copy(options.anki,       'sentenceExt', options, 'sentenceExtent');
+            copy(options.anki.term,  'deck',        options, 'ankiTermDeck');
+            copy(options.anki.term,  'model',       options, 'ankiTermModel');
+            copy(options.anki.term,  'fields',      options, 'ankiTermFields');
+            copy(options.anki.kanji, 'deck',        options, 'ankiKanjiDeck');
+            copy(options.anki.kanji, 'model',       options, 'ankiKanjiModel');
+            copy(options.anki.kanji, 'fields',      options, 'ankiKanjiFields');
+        },
     ];
 
     if (version < fixups.length) {
         fixups[version]();
         ++options.version;
-        versionOptions(options);
+        optionsVersion(options);
-    }
-}
-
-function sanitizeOptions(options) {
-    const defaults = {
-        activateOnStartup: true,
-        enableAudioPlayback: true,
-        enableSoftKatakanaSearch: true,
-        groupTermResults: true,
-        showAdvancedOptions: false,
-        selectMatchedText: true,
-        holdShiftToScan: true,
-        scanDelay: 15,
-        scanLength: 20,
-
-        dictionaries: {},
-
-        ankiEnable: false,
-        ankiCardTags: ['yomichan'],
-        sentenceExtent: 200,
-
-        ankiTermDeck: '',
-        ankiTermModel: '',
-        ankiTermFields: {},
-        ankiKanjiDeck: '',
-        ankiKanjiModel: '',
-        ankiKanjiFields: {}
-    };
-
-    for (const key in defaults) {
-        if (!(key in options)) {
-            options[key] = defaults[key];
-        }
     }
 
     return options;
 }
 
-function loadOptions() {
+function optionsLoad() {
     return new Promise((resolve, reject) => {
-        chrome.storage.sync.get(null, opts => {
+        chrome.storage.sync.get(null, options => resolve(optionsVersion(options)));
-            resolve(sanitizeOptions(opts));
-        });
     });
 }
 
-function saveOptions(opts) {
+function optionsSave(options) {
     return new Promise((resolve, reject) => {
-        chrome.storage.sync.set(sanitizeOptions(opts), resolve);
+        chrome.storage.sync.set(options, resolve);
     });
 }