cspell-lib 9.4.0 → 9.6.1

package/dist/rpc/server.js

@@ -0,0 +1,146 @@
+import { assert } from './assert.js';
+import { MalformedRPCRequestError, UnknownMethodRPCRequestError } from './errors.js';
+import { MessagePortNotifyEvents } from './MessagePortEvents.js';
+import { createRPCCanceledResponse, createRPCError, createRPCOkResponse, createRPCReadyResponse, createRPCResponse, isRPCBaseMessage, isRPCCancelRequest, isRPCOkRequest, isRPCReadyRequest, isRPCRequest, } from './modelsHelpers.js';
+const RESPONSE_CODES = {
+    OK: 200,
+    BadRequest: 400,
+    RequestTimeout: 408,
+    InternalServerError: 500,
+    ServiceUnavailable: 503,
+};
+class RPCServerImpl {
+    #portWrapper;
+    #options;
+    #allowedMethods;
+    #methods;
+    #pendingRequests;
+    constructor(config, methods) {
+        this.#portWrapper = new MessagePortNotifyEvents(config.port);
+        this.#options = config;
+        this.#methods = methods;
+        this.#allowedMethods = new Set(Object.keys(this.#methods).filter((k) => typeof this.#methods[k] === 'function'));
+        this.#pendingRequests = new Map();
+        this.#portWrapper.onMessage((msg) => this.#handleMessage(msg));
+        this.#portWrapper.start();
+        this.#sendReadyResponse();
+    }
+    get #isClosed() {
+        return this.#portWrapper.isClosed;
+    }
+    #sendResponse(response) {
+        if (this.#isClosed)
+            return;
+        this.#portWrapper.postMessage(response);
+    }
+    #handleMessage(msg) {
+        let id = 0;
+        try {
+            if (!isRPCBaseMessage(msg)) {
+                if (this.#options.returnMalformedRPCRequestError) {
+                    throw new MalformedRPCRequestError('Malformed RPC request', msg);
+                }
+                // Not a valid RPC message; ignore.
+                return;
+            }
+            id = msg.id;
+            if (isRPCCancelRequest(msg)) {
+                // For now just remove it from pending requests.
+                // later, implement aborting the request if possible.
+                this.#pendingRequests.delete(msg.id);
+                this.#sendCancelResponse(msg.id, RESPONSE_CODES.OK);
+                return;
+            }
+            if (isRPCReadyRequest(msg)) {
+                this.#sendReadyResponse(msg.id);
+                return;
+            }
+            if (isRPCOkRequest(msg)) {
+                this.#sendResponse(createRPCOkResponse(msg.id, RESPONSE_CODES.OK));
+                return;
+            }
+            if (!isRPCRequest(msg)) {
+                if (this.#options.returnMalformedRPCRequestError) {
+                    throw new MalformedRPCRequestError('Malformed RPC request', msg);
+                }
+                // Not a request; ignore.
+                return;
+            }
+            this.#handleRequest(msg);
+        }
+        catch (err) {
+            this.#sendErrorResponse(id, err);
+        }
+    }
+    #sendReadyResponse(id) {
+        this.#sendResponse(createRPCReadyResponse(id || 0, RESPONSE_CODES.OK));
+    }
+    #isMethod(method) {
+        return this.#allowedMethods.has(method);
+    }
+    #handleRequest(msg) {
+        const handleAsync = async () => {
+            if (!this.#isMethod(msg.method)) {
+                this.#sendErrorResponse(msg.id, new UnknownMethodRPCRequestError(msg.method));
+                return;
+            }
+            const method = msg.method;
+            const params = msg.params;
+            assert(Array.isArray(params), 'RPC method parameters must be an array');
+            assert(typeof this.#methods[method] === 'function', `RPC method ${method} is not a function`);
+            const result = await this.#methods[method](...params);
+            if (this.#pendingRequests.has(msg.id)) {
+                const response = createRPCResponse(msg.id, result, RESPONSE_CODES.OK);
+                this.#sendResponse(response);
+            }
+        };
+        this.#pendingRequests.set(msg.id, {
+            requestMessage: msg,
+            promise: handleAsync().catch((err) => this.#sendErrorResponse(msg.id, err, RESPONSE_CODES.InternalServerError)),
+        });
+        return;
+    }
+    #sendCancelResponse(id, code = RESPONSE_CODES.ServiceUnavailable) {
+        this.#sendResponse(createRPCCanceledResponse(id, code));
+    }
+    #sendErrorResponse(id, error, code = RESPONSE_CODES.BadRequest) {
+        try {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.#sendResponse(createRPCError(id, err, code));
+        }
+        catch {
+            // Nothing to do if the port is closed.
+        }
+    }
+    #cancelAllRequests(reason) {
+        if (!this.#pendingRequests.size)
+            return;
+        reason ??= new Error('RPC Server is shutting down');
+        for (const id of this.#pendingRequests.keys()) {
+            this.#sendErrorResponse(id, reason);
+        }
+        this.#pendingRequests.clear();
+    }
+    [Symbol.dispose]() {
+        this.#cancelAllRequests();
+        if (this.#options.closePortOnDispose) {
+            this.#portWrapper.close();
+        }
+        this.#portWrapper[Symbol.dispose]();
+    }
+}
+/**
+ * RPC Server implementation.
+ * @param ServerApi - The API methods of the server.
+ */
+export class RPCServer extends RPCServerImpl {
+    /**
+     *
+     * @param config - The server configuration, including the message port and options.
+     * @param methods - The methods to implement the API.
+     */
+    constructor(config, methods) {
+        super(config, methods);
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/rpc/types.d.ts

@@ -0,0 +1,9 @@
+export type ANY = any;
+export type OnlyFunctionsOrNever<T> = T extends (...args: ANY[]) => ANY ? T : never;
+export type ToReturnPromise<T extends (...args: ANY) => ANY> = T extends (...args: infer A) => infer R ? R extends Promise<ANY> ? (...args: A) => R : (...args: A) => Promise<R> : ANY;
+export type PromiseOrNever<T> = T extends Promise<ANY> ? T : never;
+export type RemovePromise<T> = T extends Promise<infer R> ? R : T;
+export type StringKeyOf<T> = Exclude<Extract<keyof T, string>, number | symbol>;
+export type MustExtendString<T> = T extends string ? T : never;
+export type AsPromise<T> = T extends Promise<ANY> ? T : Promise<T>;
+//# sourceMappingURL=types.d.ts.map

package/dist/rpc/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/rpc.d.ts

@@ -0,0 +1,2 @@
+export * from './rpc/index.js';
+//# sourceMappingURL=rpc.d.ts.map

package/dist/rpc.js

@@ -0,0 +1,2 @@
+export * from './rpc/index.js';
+//# sourceMappingURL=rpc.js.map

package/package.json

@@ -4,15 +4,27 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.4.0",
+  "version": "9.6.1",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
-  "types": "dist/lib/index.d.ts",
-  "module": "dist/lib/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
   "exports": {
     ".": {
-      "import": "./dist/lib/index.js"
+      "import": "./dist/index.js"
+    },
+    "./rpc": {
+      "import": "./dist/rpc/index.js"
+    },
+    "./cspell-rpc": {
+      "import": "./dist/cspell-rpc/index.js"
+    },
+    "./cspell-rpc/server": {
+      "import": "./dist/cspell-rpc/server.js"
+    },
+    "./cspell-rpc/client": {
+      "import": "./dist/cspell-rpc/client.js"
     }
   },
   "files": [
@@ -38,7 +50,7 @@
     "test": "vitest run --pool=forks",
     "test:update-snapshot": "vitest run -u",
     "test:perf": "NODE_ENV=production insight --file \"**/*.perf.{mjs,js}\"",
-    "test:perf:ts": "NODE_ENV=production insight --file \"**/*.perf.{mts,ts}\" --register ts-node/esm",
+    "test:perf:ts": "NODE_ENV=production insight --file \"**/*.perf.{mts,ts}\" ",
     "test:perf:prof": "NODE_ENV=production node --cpu-prof ../../node_modules/perf-insight/bin.mjs --file \"dist/**/*.perf.{mjs,js}\" -t 1000"
   },
   "repository": {
@@ -64,21 +76,22 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "9.4.0",
-    "@cspell/cspell-pipe": "9.4.0",
-    "@cspell/cspell-resolver": "9.4.0",
-    "@cspell/cspell-types": "9.4.0",
-    "@cspell/dynamic-import": "9.4.0",
-    "@cspell/filetypes": "9.4.0",
-    "@cspell/strong-weak-map": "9.4.0",
-    "@cspell/url": "9.4.0",
+    "@cspell/cspell-bundled-dicts": "9.6.1",
+    "@cspell/cspell-performance-monitor": "9.6.1",
+    "@cspell/cspell-pipe": "9.6.1",
+    "@cspell/cspell-resolver": "9.6.1",
+    "@cspell/cspell-types": "9.6.1",
+    "@cspell/dynamic-import": "9.6.1",
+    "@cspell/filetypes": "9.6.1",
+    "@cspell/strong-weak-map": "9.6.1",
+    "@cspell/url": "9.6.1",
     "clear-module": "^4.1.2",
-    "cspell-config-lib": "9.4.0",
-    "cspell-dictionary": "9.4.0",
-    "cspell-glob": "9.4.0",
-    "cspell-grammar": "9.4.0",
-    "cspell-io": "9.4.0",
-    "cspell-trie-lib": "9.4.0",
+    "cspell-config-lib": "9.6.1",
+    "cspell-dictionary": "9.6.1",
+    "cspell-glob": "9.6.1",
+    "cspell-grammar": "9.6.1",
+    "cspell-io": "9.6.1",
+    "cspell-trie-lib": "9.6.1",
     "env-paths": "^3.0.0",
     "gensequence": "^8.0.8",
     "import-fresh": "^3.3.1",
@@ -91,21 +104,23 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@cspell/dict-cpp": "^6.0.15",
-    "@cspell/dict-csharp": "^4.0.7",
-    "@cspell/dict-css": "^4.0.18",
+    "@cspell/cspell-tools": "9.6.1",
+    "@cspell/dict-cpp": "^7.0.2",
+    "@cspell/dict-csharp": "^4.0.8",
+    "@cspell/dict-css": "^4.0.19",
+    "@cspell/dict-en_us": "^4.4.27",
     "@cspell/dict-fa-ir": "^4.0.5",
     "@cspell/dict-fr-fr": "^2.3.2",
-    "@cspell/dict-html": "^4.0.13",
+    "@cspell/dict-html": "^4.0.14",
     "@cspell/dict-nl-nl": "^2.4.2",
-    "@cspell/dict-python": "^4.2.23",
+    "@cspell/dict-python": "^4.2.25",
     "@types/configstore": "^6.0.2",
-    "comment-json": "^4.4.1",
+    "comment-json": "^4.5.1",
     "configstore": "^7.1.0",
     "cspell-dict-nl-nl": "^1.1.2",
     "leaked-handles": "^5.2.0",
     "lorem-ipsum": "^2.0.8",
     "perf-insight": "^2.0.1"
   },
-  "gitHead": "12dba3d8b880384d1401c765cb2186647f5a266f"
+  "gitHead": "666fb79096d25c53af9519cad07030e7aca597e1"
 }

package/dist/lib/perf/perf.d.ts

@@ -1,20 +0,0 @@
-interface PerfEntry {
-    readonly entryType: string;
-    readonly name: string;
-    readonly startTime: number;
-    readonly duration?: number | undefined;
-}
-interface PerfMark extends PerfEntry {
-    readonly entryType: 'mark';
-}
-export declare class PerfMonitor {
-    private _performance;
-    private _enabled;
-    constructor(_performance?: Performance);
-    mark(name: string): PerfMark;
-    get enabled(): boolean;
-    set enabled(value: boolean);
-}
-export declare const perf: PerfMonitor;
-export {};
-//# sourceMappingURL=perf.d.ts.map

package/dist/lib/perf/perf.js

@@ -1,32 +0,0 @@
-export class PerfMonitor {
-    _performance;
-    _enabled = false;
-    constructor(_performance = performance) {
-        this._performance = _performance;
-    }
-    mark(name) {
-        const mark = ((this._enabled && this._performance.mark(name)) || {
-            entryType: 'mark',
-            name,
-            startTime: performance.now(),
-        });
-        return mark;
-    }
-    // measure(name: string, startMark: string, endMark: string) {
-    //     return this._enabled && this._performance.measure(name, startMark, endMark);
-    // }
-    // clearMarks(name?: string) {
-    //     this._enabled && this._performance.clearMarks(name);
-    // }
-    // clearMeasures(name?: string) {
-    //     this._enabled && this._performance.clearMeasures(name);
-    // }
-    get enabled() {
-        return this._enabled;
-    }
-    set enabled(value) {
-        this._enabled = value;
-    }
-}
-export const perf = new PerfMonitor();
-//# sourceMappingURL=perf.js.map

package/dist/lib/util/memorizeLastCall.d.ts

@@ -1,13 +0,0 @@
-/**
- * Create a function that memorizes the last call. If the next call is called with the same arguments, the
- * the last value is returned.
- * @param fn - function to memorize
- * @returns a new function.
- */
-export declare function memorizeLastCall<T>(fn: (...p: []) => T): (...p: []) => T;
-export declare function memorizeLastCall<T, K0>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
-export declare function memorizeLastCall<T, K0, K1>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
-export declare function memorizeLastCall<T, K0, K1, K2>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
-export declare function memorizeLastCall<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
-export declare function memorizeLastCall<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
-//# sourceMappingURL=memorizeLastCall.d.ts.map

package/dist/lib/util/memorizerWeak.d.ts

@@ -1,6 +0,0 @@
-export declare function memorizerWeak<T, K extends object>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
-export declare function memorizerWeak<T, K0 extends object, K1 extends object>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
-export declare function memorizerWeak<T, K0 extends object, K1 extends object, K2 extends object>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
-export declare function memorizerWeak<T, K0 extends object, K1 extends object, K2 extends object, K3 extends object>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
-export declare function memorizerWeak<T, K0 extends object>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
-//# sourceMappingURL=memorizerWeak.d.ts.map