expand databasePath

denops/skkeleton/config.ts

@@ -4,7 +4,9 @@ import { getKanaTable, loadKanaTableFiles } from "./kana.ts";
 import { ConfigOptions, Encode, Encoding } from "./types.ts";
 import { homeExpand } from "./util.ts";
 
-export const config: ConfigOptions = {
+export const config: Omit<ConfigOptions, "globalDictionaries"> & {
+  globalDictionaries: [string, string][];
+} = {
   acceptIllegalResult: false,
   completionRankFile: "",
   databasePath: "",
@@ -34,7 +36,7 @@ export const config: ConfigOptions = {
 };
 
 type Validators = {
-  [P in keyof typeof config]: (x: unknown) => typeof config[P];
+  [P in keyof ConfigOptions]: (x: unknown) => ConfigOptions[P];
 };
 
 function ensureEncoding(x: unknown): Encoding {
@@ -113,6 +115,35 @@ const validators: Validators = {
   userDictionary: (x) => ensure(x, is.String),
 };
 
+async function normalize(
+  denops: Denops,
+): Promise<void> {
+  config.globalDictionaries = await Promise.all(
+    config.globalDictionaries.map(async (cfg) => {
+      if (is.String(cfg)) {
+        return [await homeExpand(cfg, denops), ""];
+      } else {
+        return [await homeExpand(cfg[0], denops), cfg[1]];
+      }
+    }),
+  );
+  config.globalKanaTableFiles = await Promise.all(
+    config.globalKanaTableFiles.map(async (cfg) => {
+      if (is.String(cfg)) {
+        return await homeExpand(cfg, denops);
+      } else {
+        return [await homeExpand(cfg[0], denops), cfg[1]];
+      }
+    }),
+  );
+  config.userDictionary = await homeExpand(config.userDictionary, denops);
+  config.completionRankFile = await homeExpand(
+    config.completionRankFile,
+    denops,
+  );
+  config.databasePath = await homeExpand(config.databasePath, denops);
+}
+
 export async function setConfig(
   newConfig: Record<string, unknown>,
   denops: Denops,
@@ -134,13 +165,7 @@ export async function setConfig(
       throw Error(`Illegal option detected: ${e}`);
     }
   }
+  await normalize(denops);
 
-  const files = config.globalKanaTableFiles.map(async (
-    x,
-  ): Promise<string | [string, string]> =>
-    Array.isArray(x)
-      ? [await homeExpand(x[0], denops), x[1]]
-      : await homeExpand(x, denops)
-  );
-  await loadKanaTableFiles(await Promise.all(files));
+  await loadKanaTableFiles(await Promise.all(config.globalKanaTableFiles));
 }

denops/skkeleton/dictionary.ts

@@ -260,7 +260,7 @@ export class Library {
 }
 
 export async function load(
-  globalDictionaryConfig: (string | [string, string])[],
+  globalDictionaryConfig: [string, string][],
   userDictionaryPath: UserDictionaryPath,
 ): Promise<Library> {
   const userDictionary = new UserDictionary();

denops/skkeleton/main.ts

@@ -11,7 +11,6 @@ import { initializeStateWithAbbrev } from "./mode.ts";
 import { keyToNotation, notationToKey, receiveNotation } from "./notation.ts";
 import { currentContext, currentLibrary, variables } from "./store.ts";
 import type { CompletionData, RankData } from "./types.ts";
-import { homeExpand } from "./util.ts";
 
 type Opts = {
   key: string | string[];
@@ -65,28 +64,12 @@ async function init(denops: Denops) {
     console.log(e);
   }
   currentContext.get().denops = denops;
-  const {
-    completionRankFile,
-    userDictionary,
-  } = config;
-  const globalDictionaries = await Promise.all(
-    (config.globalDictionaries.length === 0 ? [] : config.globalDictionaries)
-      .map(async (
-        cfg,
-      ): Promise<[string, string]> => {
-        if (is.String(cfg)) {
-          return [await homeExpand(cfg, denops), ""];
-        } else {
-          return [await homeExpand(cfg[0], denops), cfg[1]];
-        }
-      }),
-  );
   currentLibrary.setInitializer(async () =>
     await loadDictionary(
-      globalDictionaries,
+      config.globalDictionaries,
       {
-        path: await homeExpand(userDictionary, denops),
-        rankPath: await homeExpand(completionRankFile, denops),
+        path: config.userDictionary,
+        rankPath: config.completionRankFile,
       },
     )
   );