feat(dev): refactor settings

jest.config.js

@@ -5,7 +5,8 @@ module.exports = {
     moduleFileExtensions: ["ts", "js", "json", "node"],
     moduleNameMapper: {
         "^@templates/(.*)$": "<rootDir>/src/$1",
-        "^api$": "<rootDir>/tests/mock-joplin-api.ts"
+        "^api$": "<rootDir>/tests/mock-joplin-api.ts",
+        "^api/types$": "<rootDir>/api/types.ts"
     },
     globalSetup: "./tests/jest-setup.js",
     collectCoverageFrom: ["src/**/*.{js,ts}"]

src/actions.ts

@@ -2,6 +2,7 @@ import joplin from "api";
 import { NewNote } from "./parser";
 import { getSelectedFolder } from "./utils/folders";
 import { applyTagToNote, getAnyTagWithTitle } from "./utils/tags";
+import { ApplyTagsWhileInsertingSetting } from "./settings";
 
 export enum TemplateAction {
     NewNote = "newNote",
@@ -12,7 +13,7 @@ export enum TemplateAction {
 const performInsertTextAction = async (template: NewNote) => {
     await joplin.commands.execute("insertText", template.body);
 
-    const applyTags = await joplin.settings.value("applyTagsWhileInserting")
+    const applyTags = await ApplyTagsWhileInsertingSetting.get()
     if (applyTags) {
         const noteId = (await joplin.workspace.selectedNote()).id;
         for (const tag of template.tags) {

src/index.ts

@@ -1,79 +1,36 @@
 import joplin from "api";
-import { MenuItemLocation, SettingItemType } from "api/types";
+import { MenuItemLocation } from "api/types";
 import { Parser } from "./parser";
 import { DateAndTimeUtils } from "./utils/dateAndTime";
 import { getFolderFromId, getSelectedFolder, getUserFolderSelection, Folder } from "./utils/folders";
-import { clearDefaultTemplates, getNotebookDefaultTemplatesConfig, getUserDefaultTemplateTypeSelection, setDefaultTemplate, DefaultTemplatesConfigSetting } from "./utils/defaultTemplates";
+import { getUserDefaultTemplateTypeSelection, setDefaultTemplate } from "./utils/defaultTemplates";
 import { getTemplateFromId, getUserTemplateSelection, Note } from "./utils/templates";
 import { setDefaultTemplatesView, DefaultTemplatesDisplayData, NotebookDefaultTemplatesDisplayData } from "./views/defaultTemplates";
 import { TemplateAction, performAction } from "./actions";
 import { loadLegacyTemplates } from "./legacyTemplates";
 import * as open from "open";
 import { Logger } from "./logger";
 import { PromiseGroup } from "./utils/promises";
+import { PluginSettingsRegistry, DefaultNoteTemplateIdSetting, DefaultTodoTemplateIdSetting, DefaultTemplatesConfigSetting } from "./settings";
+import { LocaleGlobalSetting, DateFormatGlobalSetting, TimeFormatGlobalSetting, ProfileDirGlobalSetting } from "./settings/global";
+import { DefaultTemplatesConfig } from "./settings/defaultTemplatesConfig";
 
 const DOCUMENTATION_URL = "https://github.com/joplin/plugin-templates#readme";
 
 joplin.plugins.register({
     onStart: async function() {
         // Register setting section
-        await joplin.settings.registerSection("templatesPlugin", {
-            label: "Templates",
-        });
-
-
-        // Register all settings
-        await joplin.settings.registerSettings({
-            "defaultNoteTemplateId": {
-                public: false,
-                type: SettingItemType.String,
-                value: null,
-                label: "Default note template ID"
-            },
-            "defaultTodoTemplateId": {
-                public: false,
-                type: SettingItemType.String,
-                value: null,
-                label: "Default to-do template ID"
-            },
-            "defaultTemplatesConfig": {
-                public: false,
-                type: SettingItemType.Object,
-                value: null,
-                label: "Default templates config"
-            },
-            "applyTagsWhileInserting": {
-                public: true,
-                type: SettingItemType.Bool,
-                value: true,
-                label: "Apply tags while inserting template",
-                description: "Apply tags using 'template_tags' variable while inserting template to notes/to-dos.",
-                section: "templatesPlugin"
-            },
-            "templatesSource": {
-                public: true,
-                type: SettingItemType.String,
-                isEnum: true,
-                value: "tag",
-                options: {
-                    "tag": "Tag",
-                    "notebook": "Notebook"
-                },
-                label: "Are templates set with tags or stored in a notebook?",
-                description: "If set to 'Tag', any note/to-do with a 'template' tag is considered a template. If set to 'Notebook', any note/todo stored in a notebook titled 'Templates' is considered a template.",
-                section: "templatesPlugin"
-            },
-        });
+        await PluginSettingsRegistry.registerSettings();
 
 
         // Global variables
         const joplinGlobalApis = new PromiseGroup();
 
         joplinGlobalApis.set("dialogViewHandle", joplin.views.dialogs.create("dialog"));
-        joplinGlobalApis.set("userLocale", joplin.settings.globalValue("locale"));
-        joplinGlobalApis.set("userDateFormat", joplin.settings.globalValue("dateFormat"));
-        joplinGlobalApis.set("userTimeFormat", joplin.settings.globalValue("timeFormat"));
-        joplinGlobalApis.set("profileDir", joplin.settings.globalValue("profileDir"));
+        joplinGlobalApis.set("userLocale", LocaleGlobalSetting.get());
+        joplinGlobalApis.set("userDateFormat", DateFormatGlobalSetting.get());
+        joplinGlobalApis.set("userTimeFormat", TimeFormatGlobalSetting.get());
+        joplinGlobalApis.set("profileDir", ProfileDirGlobalSetting.get());
 
         const {
             dialogViewHandle, userLocale, userDateFormat,
@@ -102,7 +59,7 @@ joplin.plugins.register({
             await performActionWithParsedTemplate(action, template);
         }
 
-        const getNotebookDefaultTemplatesDisplayData = async (settings: DefaultTemplatesConfigSetting): Promise<NotebookDefaultTemplatesDisplayData[]> => {
+        const getNotebookDefaultTemplatesDisplayData = async (settings: DefaultTemplatesConfig): Promise<NotebookDefaultTemplatesDisplayData[]> => {
             const getDisplayDataForNotebook = async (notebookId: string, defaultTemplateNoteId: string | null, defaultTemplateTodoId: string | null): Promise<NotebookDefaultTemplatesDisplayData | null> => {
                 const promiseGroup = new PromiseGroup();
                 promiseGroup.set("notebook", getFolderFromId(notebookId));
@@ -112,7 +69,7 @@ joplin.plugins.register({
 
                 if (notebook === null || (noteTemplate === null && todoTemplate === null)) {
                     // Async remove of the obsolete config
-                    clearDefaultTemplates(notebookId);
+                    DefaultTemplatesConfigSetting.clearDefaultTemplates(notebookId);
                     return null;
                 }
                 return {
@@ -162,9 +119,9 @@ joplin.plugins.register({
             name: "showDefaultTemplates",
             label: "Show default templates",
             execute: async () => {
-                const noteTemplate = await getTemplateFromId(await joplin.settings.value("defaultNoteTemplateId"));
-                const todoTemplate = await getTemplateFromId(await joplin.settings.value("defaultTodoTemplateId"));
-                const defaultTemplatesConfig = await getNotebookDefaultTemplatesConfig();
+                const noteTemplate = await getTemplateFromId(await DefaultNoteTemplateIdSetting.get());
+                const todoTemplate = await getTemplateFromId(await DefaultTodoTemplateIdSetting.get());
+                const defaultTemplatesConfig = await DefaultTemplatesConfigSetting.get();
 
                 const globalDefaultTemplates: DefaultTemplatesDisplayData = {
                     defaultNoteTemplateTitle: noteTemplate ? noteTemplate.title : null,
@@ -217,7 +174,7 @@ joplin.plugins.register({
                 const folder: Folder | null = JSON.parse(await getUserFolderSelection() || "null");
                 if (folder === null) return;
 
-                await clearDefaultTemplates(folder.id);
+                await DefaultTemplatesConfigSetting.clearDefaultTemplates(folder.id);
                 await joplin.views.dialogs.showMessageBox(`Default templates for "${folder.title}" cleared successfully!`);
             }
         }));
@@ -228,15 +185,15 @@ joplin.plugins.register({
             execute: async () => {
                 let defaultTemplate: Note | null = null;
 
-                const defaultTemplatesConfig = await getNotebookDefaultTemplatesConfig();
+                const defaultTemplatesConfig = await DefaultTemplatesConfigSetting.get();
                 const currentFolderId = await getSelectedFolder();
 
                 if (currentFolderId in defaultTemplatesConfig) {
                     defaultTemplate = await getTemplateFromId(defaultTemplatesConfig[currentFolderId].defaultNoteTemplateId);
                 }
 
                 if (defaultTemplate === null) {
-                    defaultTemplate = await getTemplateFromId(await joplin.settings.value("defaultNoteTemplateId"));
+                    defaultTemplate = await getTemplateFromId(await DefaultNoteTemplateIdSetting.get());
                 }
 
                 if (defaultTemplate) {
@@ -252,15 +209,15 @@ joplin.plugins.register({
             execute: async () => {
                 let defaultTemplate: Note | null = null;
 
-                const defaultTemplatesConfig = await getNotebookDefaultTemplatesConfig();
+                const defaultTemplatesConfig = await DefaultTemplatesConfigSetting.get();
                 const currentFolderId = await getSelectedFolder();
 
                 if (currentFolderId in defaultTemplatesConfig) {
                     defaultTemplate = await getTemplateFromId(defaultTemplatesConfig[currentFolderId].defaultTodoTemplateId);
                 }
 
                 if (defaultTemplate === null) {
-                    defaultTemplate = await getTemplateFromId(await joplin.settings.value("defaultTodoTemplateId"));
+                    defaultTemplate = await getTemplateFromId(await DefaultTodoTemplateIdSetting.get());
                 }
 
                 if (defaultTemplate) {

src/settings/applyTagsWhileInserting.ts

@@ -0,0 +1,11 @@
+import { SettingItemType } from "api/types";
+import { createSimpleSetting } from "./base";
+
+export const ApplyTagsWhileInsertingSetting = createSimpleSetting<boolean>("applyTagsWhileInserting", {
+    public: true,
+    type: SettingItemType.Bool,
+    value: true,
+    label: "Apply tags while inserting template",
+    description: "Apply tags using 'template_tags' variable while inserting template to notes/to-dos.",
+    section: "templatesPlugin"
+});

src/settings/base.ts

@@ -0,0 +1,46 @@
+import joplin from "api";
+import { SettingItem } from "api/types";
+
+export interface PluginSetting<T> {
+    id: string;
+    manifest: SettingItem;
+
+    get(): Promise<T>;
+    set(newValue: T): Promise<void>;
+}
+
+export const createSimpleSetting = <T>(id: string, manifest: SettingItem): PluginSetting<T> => {
+    return class {
+        static id = id;
+        static manifest = manifest;
+
+        static async get(): Promise<T> {
+            return await joplin.settings.value(id);
+        }
+
+        static async set(newValue: T): Promise<void> {
+            await joplin.settings.setValue(id, newValue);
+        }
+    }
+}
+
+/**
+ * This considers that the original setting is of type `string`. On `set` if no original value
+ * can be traced back, the setting is set to an empty string.
+ */
+export const createMappedSetting = <T>(id: string, manifest: SettingItem, valueMap: Record<string, T>, defaultValue: T): PluginSetting<T> => {
+    return class {
+        static id = id;
+        static manifest = manifest;
+
+        static async get(): Promise<T> {
+            const value: string = await joplin.settings.value(id);
+            return value in valueMap ? valueMap[value] : defaultValue;
+        }
+
+        static async set(newValue: T): Promise<void> {
+            const potentialValues = Object.entries(valueMap).filter((entry) => entry[1] === newValue);
+            await joplin.settings.setValue(id, potentialValues.length ? potentialValues[0][0] : "" );
+        }
+    }
+}

src/settings/defaultNoteTemplateId.ts

@@ -0,0 +1,9 @@
+import { SettingItemType } from "api/types";
+import { createSimpleSetting } from "./base";
+
+export const DefaultNoteTemplateIdSetting = createSimpleSetting<string | null>("defaultNoteTemplateId", {
+    public: false,
+    type: SettingItemType.String,
+    value: null,
+    label: "Default note template ID"
+});

src/settings/defaultTemplatesConfig.ts

@@ -0,0 +1,71 @@
+import joplin from "api";
+import { SettingItemType } from "api/types";
+
+export interface DefaultTemplatesConfig {
+    [notebookId: string]: {
+        defaultNoteTemplateId: string | null;
+        defaultTodoTemplateId: string | null;
+    }
+}
+
+enum DefaultType {
+    Both,
+    Note,
+    Todo,
+}
+
+export const DefaultTemplatesConfigSetting = class {
+    static readonly DefaultType = DefaultType;
+
+    static id = "defaultTemplatesConfig";
+
+    static manifest = {
+        public: false,
+        type: SettingItemType.Object,
+        value: null,
+        label: "Default templates config"
+    };
+
+    static async get(): Promise<DefaultTemplatesConfig> {
+        const defaultTemplatesConfig: DefaultTemplatesConfig | null = await joplin.settings.value(DefaultTemplatesConfigSetting.id);
+        return defaultTemplatesConfig ? defaultTemplatesConfig : {};
+    }
+
+    static async set(newValue: DefaultTemplatesConfig): Promise<void> {
+        await joplin.settings.setValue(DefaultTemplatesConfigSetting.id, newValue);
+    }
+
+    static async setDefaultTempalte(notebookId: string, templateId: string, defaultType: DefaultType): Promise<void> {
+        const defaultTemplatesConfig = await this.get();
+
+        if (!(notebookId in defaultTemplatesConfig)) {
+            defaultTemplatesConfig[notebookId] = {
+                defaultNoteTemplateId: null,
+                defaultTodoTemplateId: null
+            };
+        }
+
+        switch (defaultType) {
+            case DefaultType.Note:
+                defaultTemplatesConfig[notebookId].defaultNoteTemplateId = templateId;
+                break;
+            case DefaultType.Todo:
+                defaultTemplatesConfig[notebookId].defaultTodoTemplateId = templateId;
+                break;
+            case DefaultType.Both:
+                defaultTemplatesConfig[notebookId].defaultNoteTemplateId = templateId;
+                defaultTemplatesConfig[notebookId].defaultTodoTemplateId = templateId;
+                break;
+            default:
+                break;
+        }
+
+        await this.set(defaultTemplatesConfig);
+    }
+
+    static async clearDefaultTemplates(notebookId: string): Promise<void> {
+        const defaultTemplatesConfig = await this.get();
+        delete defaultTemplatesConfig[notebookId];
+        await this.set(defaultTemplatesConfig);
+    }
+}

src/settings/defaultTodoTemplateId.ts

@@ -0,0 +1,9 @@
+import { SettingItemType } from "api/types";
+import { createSimpleSetting } from "./base";
+
+export const DefaultTodoTemplateIdSetting = createSimpleSetting<string | null>("defaultTodoTemplateId", {
+    public: false,
+    type: SettingItemType.String,
+    value: null,
+    label: "Default to-do template ID"
+});

src/settings/global/base.ts

@@ -0,0 +1,16 @@
+import joplin from "api";
+
+export interface GlobalSetting<T> {
+    id: string;
+    get(): Promise<T>;
+}
+
+export const createGlobalSetting = <T>(id: string): GlobalSetting<T> => {
+    return class {
+        static id = id;
+
+        static async get(): Promise<T> {
+            return await joplin.settings.globalValue(id);
+        }
+    }
+}

src/settings/global/index.ts

@@ -0,0 +1,9 @@
+import { createGlobalSetting } from "./base";
+
+export const LocaleGlobalSetting = createGlobalSetting<string>("locale");
+
+export const DateFormatGlobalSetting = createGlobalSetting<string>("dateFormat");
+
+export const TimeFormatGlobalSetting = createGlobalSetting<string>("timeFormat");
+
+export const ProfileDirGlobalSetting = createGlobalSetting<string>("profileDir");

src/settings/index.ts

@@ -0,0 +1,9 @@
+// Export all individual settings
+export { ApplyTagsWhileInsertingSetting } from "./applyTagsWhileInserting";
+export { DefaultNoteTemplateIdSetting } from "./defaultNoteTemplateId";
+export { DefaultTemplatesConfigSetting } from "./defaultTemplatesConfig";
+export { DefaultTodoTemplateIdSetting } from "./defaultTodoTemplateId";
+export { TemplatesSourceSetting } from "./templatesSource";
+
+// Export registry
+export { PluginSettingsRegistry } from "./registry";