fix: Add CSpellRPCServer and CSpellRPCClient classes

cspell-dict.txt

@@ -34,6 +34,7 @@ licia
 linkcode
 liriliri
 megistos
+memoizer
 mkdir
 monkeyc
 mshick

cspell.code-workspace

@@ -25,6 +25,7 @@
         { "path": "packages/cspell-trie" },
         { "path": "packages/cspell-types" },
         { "path": "packages/cspell-url" },
+        { "path": "packages/cspell-worker" },
         { "path": "packages/cspell" },
         { "path": "packages/dynamic-import" },
         { "path": "packages/flatpack-json" },

packages/cspell-lib/package.json

@@ -13,6 +13,12 @@
   "exports": {
     ".": {
       "import": "./dist/lib/index.js"
+    },
+    "./rpc": {
+      "import": "./dist/rpc/index.js"
+    },
+    "./cspell-rpc": {
+      "import": "./dist/cspell-rpc/index.js"
     }
   },
   "files": [

packages/cspell-lib/src/cspell-rpc/cspellRPC.test.ts

@@ -0,0 +1,64 @@
+import { MessageChannel } from 'node:worker_threads';
+
+import { describe, expect, test, vi } from 'vitest';
+
+import type { MessagePortLike } from './cspellRPC.js';
+import { CSpellRPCClient, CSpellRPCServer } from './cspellRPC.js';
+
+const oc = (...params: Parameters<typeof expect.objectContaining>) => expect.objectContaining(...params);
+
+describe('Validate Client / Server communications', () => {
+    test('Check creation', async () => {
+        const { client, server, portClient, portServer } = createClientServerPair();
+
+        expect(client).toBeDefined();
+        expect(server).toBeDefined();
+
+        expect(portClient.addListener).toHaveBeenCalled();
+        expect(portServer.addListener).toHaveBeenCalled();
+    });
+
+    test('spell checking a document.', async () => {
+        const { client } = createClientServerPair();
+
+        const api = client.getApi();
+        expect(api).toBeDefined();
+        expect(api.spellCheckDocument).toBeDefined();
+
+        const doc = { uri: import.meta.url };
+        const result = await api.spellCheckDocument(doc, {}, {});
+        expect(result).toBeDefined();
+        expect(result).toEqual(oc({ issues: [], errors: undefined }));
+
+        const result2 = await api.spellCheckDocument(doc, {}, {});
+        expect(result2).toBeDefined();
+        expect(result2).toEqual(oc({ issues: [], errors: undefined }));
+    });
+});
+
+interface ClientServerPair {
+    client: CSpellRPCClient;
+    server: CSpellRPCServer;
+    portClient: MessagePortLike;
+    portServer: MessagePortLike;
+}
+
+function createClientServerPair(): ClientServerPair {
+    const channel = new MessageChannel();
+    const portClient = channel.port1;
+    const portServer = channel.port2;
+    spyOnPort(portServer);
+    spyOnPort(portClient);
+
+    const server = new CSpellRPCServer(portServer);
+    const client = new CSpellRPCClient(portClient);
+
+    return { client, server, portClient, portServer };
+}
+
+function spyOnPort(port: MessagePortLike) {
+    const spyOnAddListener = vi.spyOn(port, 'addListener');
+    const spyOnStart = vi.spyOn(port, 'start');
+    const spyOnClose = vi.spyOn(port, 'close');
+    return { spyOnAddListener, spyOnStart, spyOnClose };
+}

packages/cspell-lib/src/cspell-rpc/cspellRPC.ts

@@ -0,0 +1,62 @@
+import { randomUUID } from 'node:crypto';
+
+import type { MessagePortLike, RPCClientOptions, RPCProtocol, RPCServerOptions } from '../rpc/index.js';
+import { RPCClient, RPCServer } from '../rpc/index.js';
+import type { spellCheckDocumentRPC } from './spellCheckFile.js';
+
+export type { MessagePortLike } from '../rpc/index.js';
+
+export interface CSpellRPCApi {
+    spellCheckDocument: typeof spellCheckDocumentRPC;
+}
+
+export type CSpellRPCServerOptions = RPCServerOptions;
+
+export class CSpellRPCServer extends RPCServer<CSpellRPCApi> {
+    constructor(port: MessagePortLike, options?: CSpellRPCServerOptions) {
+        super(port, getCSpellRPCApi(), options);
+    }
+}
+
+export function createCSpellRPCServer(port: MessagePortLike, options?: CSpellRPCServerOptions): CSpellRPCServer {
+    return new CSpellRPCServer(port, options);
+}
+
+export type CSpellRPCClientOptions = RPCClientOptions;
+
+export class CSpellRPCClient extends RPCClient<CSpellRPCApi> {
+    constructor(port: MessagePortLike, options?: CSpellRPCClientOptions) {
+        super(port, { randomUUID, ...options });
+    }
+
+    getApi(): RPCProtocol<CSpellRPCApi> {
+        return super.getApi(Object.keys(getCSpellRPCApi()) as Array<keyof CSpellRPCApi>);
+    }
+}
+
+export function createCSpellRPCClient(port: MessagePortLike, options?: CSpellRPCClientOptions): CSpellRPCClient {
+    return new CSpellRPCClient(port, options);
+}
+
+let pSpellCheckFileJs: Promise<{ spellCheckDocumentRPC: typeof spellCheckDocumentRPC }> | undefined = undefined;
+
+/**
+ * Get the CSpell RPC API.
+ *
+ * NOTE: This function lazy loads the implementation to avoid loading unnecessary during initialization of workers.
+ *
+ * @returns the api implementation.
+ */
+function getCSpellRPCApi(): CSpellRPCApi {
+    return {
+        spellCheckDocument: async (...params) => {
+            const { spellCheckDocumentRPC } = await getSpellCheckFileJs();
+            return spellCheckDocumentRPC(...params);
+        },
+    };
+
+    function getSpellCheckFileJs() {
+        pSpellCheckFileJs ??= import('./spellCheckFile.js');
+        return pSpellCheckFileJs;
+    }
+}

packages/cspell-lib/src/cspell-rpc/index.ts

@@ -0,0 +1,8 @@
+export type { CSpellRPCApi } from './cspellRPC.js';
+export {
+    createCSpellRPCClient,
+    createCSpellRPCServer,
+    CSpellRPCClient,
+    CSpellRPCServer,
+    CSpellRPCServerOptions,
+} from './cspellRPC.js';

packages/cspell-lib/src/cspell-rpc/spellCheckFile.ts

@@ -0,0 +1 @@
+export { spellCheckDocumentRPC } from '../lib/spellCheckFile.js';

packages/cspell-lib/src/lib/Settings/LanguageSettings.ts

@@ -35,12 +35,12 @@ function stringToList(sList: string): string[] {
         .filter((s) => !!s);
 }
 
-function memorizer<K, V>(resolver: (k: K) => V): (k: K) => V {
+function memoize<K, V>(resolver: (k: K) => V): (k: K) => V {
     const cache = createAutoResolveCache<K, V>();
     return (k: K) => cache.get(k, resolver);
 }
 
-const _normalizeLanguageId = memorizer(__normalizeLanguageId);
+const _normalizeLanguageId = memoize(__normalizeLanguageId);
 function __normalizeLanguageId(langId: LanguageId): Set<LanguageId> {
     const langIds = stringToList(langId);
     return new Set<LanguageId>(langIds.map((a) => a.toLowerCase()));
@@ -50,7 +50,7 @@ export function normalizeLanguageId(langId: LanguageId | LanguageId[]): Set<Lang
     return _normalizeLanguageId(typeof langId === 'string' ? langId : langId.join(','));
 }
 
-const _normalizeLocale = memorizer(__normalizeLocale);
+const _normalizeLocale = memoize(__normalizeLocale);
 function __normalizeLocale(locale: LocaleId): Set<LocaleId> {
     const locales = localesToList(locale);
     return new Set<LocaleId>(locales.map((locale) => locale.toLowerCase().replaceAll(/[^a-z]/g, '')));