feat(core): add Electron runtime, services, and app composition

src/main/runtime/yomitan-extension-runtime.test.ts

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { Extension } from 'electron';
+import { createYomitanExtensionRuntime } from './yomitan-extension-runtime';
+
+test('yomitan extension runtime reuses in-flight ensure load and clears it after resolve', async () => {
+  let extension: Extension | null = null;
+  let inFlight: Promise<Extension | null> | null = null;
+  let parserWindow: unknown = null;
+  let readyPromise: Promise<void> | null = null;
+  let initPromise: Promise<boolean> | null = null;
+  let loadCalls = 0;
+  const releaseLoadState: { releaseLoad: ((value: Extension | null) => void) | null } = {
+    releaseLoad: null,
+  };
+
+  const runtime = createYomitanExtensionRuntime({
+    loadYomitanExtensionCore: async (options) => {
+      loadCalls += 1;
+      options.setYomitanParserWindow(null);
+      options.setYomitanParserReadyPromise(Promise.resolve());
+      options.setYomitanParserInitPromise(Promise.resolve(true));
+      return await new Promise<Extension | null>((resolve) => {
+        releaseLoadState.releaseLoad = (value) => {
+          options.setYomitanExtension(value);
+          resolve(value);
+        };
+      });
+    },
+    userDataPath: '/tmp',
+    getYomitanParserWindow: () => parserWindow as never,
+    setYomitanParserWindow: (window) => {
+      parserWindow = window;
+    },
+    setYomitanParserReadyPromise: (promise) => {
+      readyPromise = promise as Promise<void> | null;
+    },
+    setYomitanParserInitPromise: (promise) => {
+      initPromise = promise as Promise<boolean> | null;
+    },
+    setYomitanExtension: (next) => {
+      extension = next;
+    },
+    getYomitanExtension: () => extension,
+    getLoadInFlight: () => inFlight,
+    setLoadInFlight: (promise) => {
+      inFlight = promise;
+    },
+  });
+
+  const first = runtime.ensureYomitanExtensionLoaded();
+  const second = runtime.ensureYomitanExtensionLoaded();
+  assert.equal(loadCalls, 1);
+  assert.ok(inFlight);
+  assert.equal(parserWindow, null);
+  assert.ok(readyPromise);
+  assert.ok(initPromise);
+
+  const fakeExtension = { id: 'yomitan' } as Extension;
+  const releaseLoad = releaseLoadState.releaseLoad;
+  if (!releaseLoad) {
+    throw new Error('expected in-flight yomitan load resolver');
+  }
+  releaseLoad(fakeExtension);
+  assert.equal(await first, fakeExtension);
+  assert.equal(await second, fakeExtension);
+  assert.equal(extension, fakeExtension);
+  assert.equal(inFlight, null);
+
+  const third = await runtime.ensureYomitanExtensionLoaded();
+  assert.equal(third, fakeExtension);
+  assert.equal(loadCalls, 1);
+});
+
+test('yomitan extension runtime direct load delegates to core', async () => {
+  let loadCalls = 0;
+
+  const runtime = createYomitanExtensionRuntime({
+    loadYomitanExtensionCore: async () => {
+      loadCalls += 1;
+      return null;
+    },
+    userDataPath: '/tmp',
+    getYomitanParserWindow: () => null,
+    setYomitanParserWindow: () => {},
+    setYomitanParserReadyPromise: () => {},
+    setYomitanParserInitPromise: () => {},
+    setYomitanExtension: () => {},
+    getYomitanExtension: () => null,
+    getLoadInFlight: () => null,
+    setLoadInFlight: () => {},
+  });
+
+  assert.equal(await runtime.loadYomitanExtension(), null);
+  assert.equal(loadCalls, 1);
+});