cspell-lib 9.6.2 → 9.6.3

package/dist/rpc/modelsHelpers.js

@@ -1,117 +0,0 @@
-const RequestTypeNames = {
-    ready: 'ready',
-    request: 'request',
-    cancel: 'cancel',
-    ok: 'ok',
-};
-const ResponseTypeNames = {
-    ready: 'ready',
-    response: 'response',
-    canceled: 'canceled',
-    ok: 'ok',
-};
-const knownRPCMessageTypes = new Set([...Object.keys(RequestTypeNames), ...Object.keys(ResponseTypeNames)]);
-const sig = 'RPC0';
-export function isRPCBaseMessage(message) {
-    if (!message || typeof message !== 'object')
-        return false;
-    const m = message;
-    return m.sig === sig && (typeof m.id === 'string' || typeof m.id === 'number') && knownRPCMessageTypes.has(m.type);
-}
-export function isBaseRequest(message) {
-    return message.type in RequestTypeNames;
-}
-export function isBaseResponse(message) {
-    return isRPCBaseMessage(message) && message.type in ResponseTypeNames;
-}
-export function isRPCErrorResponse(response) {
-    return (isBaseResponse(response) &&
-        response.type === ResponseTypeNames.response &&
-        response.error !== undefined);
-}
-export function isRPCCancelRequest(request) {
-    return request.type === RequestTypeNames.cancel;
-}
-export function isRPCCanceledResponse(response) {
-    return response.type === ResponseTypeNames.canceled;
-}
-export function isRPCOkRequest(request) {
-    return request.type === RequestTypeNames.ok;
-}
-export function isRPCOkResponse(response) {
-    return response.type === ResponseTypeNames.ok && typeof response.code === 'number';
-}
-export function isRPCReadyRequest(request) {
-    return request.type === RequestTypeNames.ready;
-}
-export function isRPCReadyResponse(response) {
-    return response.type === ResponseTypeNames.ready && typeof response.code === 'number';
-}
-export function isRPCResponse(response) {
-    return response.type === ResponseTypeNames.response && 'result' in response;
-}
-export function isRPCRequest(message) {
-    return message.type === RequestTypeNames.request && message.method !== undefined;
-}
-/**
- * Creates a RPC Request Message.
- * @param id - The unique request identifier.
- * @param method - The method name.
- * @param params - The parameters for the request.
- * @returns A RPC Request Message.
- */
-export function createRPCMethodRequest(id, method, params) {
-    return { sig, id, type: RequestTypeNames.request, method, params };
-}
-/**
- * Creates a cancel request message.
- * @param id - The request ID to be canceled.
- * @returns A cancel request message.
- */
-export function createRPCCancelRequest(id) {
-    return { sig, id, type: RequestTypeNames.cancel };
-}
-/**
- * Creates a cancel request message.
- * @param id - The request ID to be canceled.
- * @param code - The response code
- *   - 200 (ok) - if canceled successfully upon request.
- *   - 408 (timeout) - if the cancellation was initiated by the server.
- *   - 503 (unavailable) - if the server is shutting down.
- * @returns A cancel request message.
- */
-export function createRPCCanceledResponse(id, code) {
-    return { sig, id, type: ResponseTypeNames.canceled, code };
-}
-/**
- * Creates a RPC Response Message.
- * @param id - The matching request ID.
- * @param result - the result of the request.
- * @returns A RPC Response Message.
- */
-export function createRPCResponse(id, result, code) {
-    return { sig, id, type: ResponseTypeNames.response, code, result };
-}
-/**
- * Creates a RPC Error Message.
- * @param id - The matching request ID for which the error occurred.
- * @param error - The error information.
- * @returns A RPC Error Message.
- */
-export function createRPCError(id, error, code) {
-    const msg = { sig, id, type: ResponseTypeNames.response, code, error };
-    return msg;
-}
-export function createRPCOkRequest(id) {
-    return { sig, id, type: RequestTypeNames.ok };
-}
-export function createRPCOkResponse(id, code) {
-    return { sig, id, type: ResponseTypeNames.ok, code };
-}
-export function createRPCReadyRequest(id) {
-    return { sig, id, type: RequestTypeNames.ready };
-}
-export function createRPCReadyResponse(id, code) {
-    return { sig, id, type: ResponseTypeNames.ready, code };
-}
-//# sourceMappingURL=modelsHelpers.js.map

package/dist/rpc/notify.d.ts

@@ -1,79 +0,0 @@
-export type NotifyHandler<T> = (event: T) => void;
-export type NotifyEvent<T> = (handler: NotifyHandler<T>) => Disposable;
-/**
- * Used to have a type distinction between NotifyOnceEvents and NotifyEvents.
- * It is not used at runtime.
- */
-declare const SymbolNotifyOnceEvent: unique symbol;
-export type NotifyOnceEvent<T> = NotifyEvent<T> & {
-    [SymbolNotifyOnceEvent]?: true;
-};
-/**
- * A Class used to emit notifications to registered handlers.
- */
-export declare class NotifyEmitter<T> {
-    #private;
-    /**
-     * Registers a handler for the event. Multiple handlers can be added. The same handler will
-     * not be added more than once. To add the same handler multiple times, use a wrapper function.
-     *
-     * The handler will NOT be called during the registration. They will be called when {@link notify} is called.
-     *
-     * Note: This function can be used without needing to bind 'this'.
-     * @param handler - the handler to add.
-     * @returns a Disposable to remove the handler.
-     */
-    readonly onEvent: NotifyEvent<T>;
-    /**
-     * Notify all handlers of the event.
-     *
-     * If a handler throws an error, the error is not caught and will propagate up the call stack.
-     *
-     * Note: This function can be used without needing to bind 'this'.
-     * @param value - The event value.
-     */
-    readonly notify: (value: T) => void;
-    /**
-     * A NotifyEvent that only fires once for each handler added.
-     *
-     * Multiple handlers can be added. The same handler can be added multiple times
-     * and will be called once for each time it is added.
-     *
-     * Note: This property can be used without needing to bind 'this'.
-     */
-    readonly once: NotifyOnceEvent<T>;
-    /**
-     * Get a Promise that resolves with the next event.
-     * @param signal - A signal to abort the wait.
-     * @returns a Promise that will resolve with the next value emitted.
-     */
-    readonly awaitNext: (signal?: AbortSignal) => Promise<T>;
-    /**
-     * The number of registered handlers.
-     */
-    get size(): number;
-    /**
-     * Removes all registered handlers.
-     */
-    clear(): void;
-    [Symbol.dispose](): void;
-}
-/**
- * Convert a NotifyEvent to a Promise.
- * @param event - The event to convert.
- * @param signal - Optional AbortSignal to cancel the subscription if the promise is abandoned.
- * @returns A Promise that resolves with the first value emitted by the event.
- */
-export declare function notifyEventToPromise<T>(event: NotifyEvent<T>, signal?: AbortSignal): Promise<T>;
-/**
- * Create a NotifyEvent that only fires once.
- *
- * The same handler can be added multiple times and will be called once for each time it is added.
- * This is different from a normal NotifyEvent where the same handler is only added once.
- *
- * @param event - The event to wrap.
- * @returns A NotifyOnceEvent that only fires once for the handlers added.
- */
-export declare function notifyEventOnce<T>(event: NotifyEvent<T>): NotifyOnceEvent<T>;
-export {};
-//# sourceMappingURL=notify.d.ts.map

package/dist/rpc/notify.js

@@ -1,135 +0,0 @@
-import { AlreadyDisposedError } from './errors.js';
-/**
- * A Class used to emit notifications to registered handlers.
- */
-export class NotifyEmitter {
-    #handlers = new Map();
-    #disposed = false;
-    /**
-     * Registers a handler for the event. Multiple handlers can be added. The same handler will
-     * not be added more than once. To add the same handler multiple times, use a wrapper function.
-     *
-     * The handler will NOT be called during the registration. They will be called when {@link notify} is called.
-     *
-     * Note: This function can be used without needing to bind 'this'.
-     * @param handler - the handler to add.
-     * @returns a Disposable to remove the handler.
-     */
-    onEvent = (handler) => this.#onEvent(handler);
-    /**
-     * Notify all handlers of the event.
-     *
-     * If a handler throws an error, the error is not caught and will propagate up the call stack.
-     *
-     * Note: This function can be used without needing to bind 'this'.
-     * @param value - The event value.
-     */
-    notify = (value) => this.#notify(value);
-    /**
-     * A NotifyEvent that only fires once for each handler added.
-     *
-     * Multiple handlers can be added. The same handler can be added multiple times
-     * and will be called once for each time it is added.
-     *
-     * Note: This property can be used without needing to bind 'this'.
-     */
-    once = notifyEventOnce(this.onEvent);
-    /**
-     * Get a Promise that resolves with the next event.
-     * @param signal - A signal to abort the wait.
-     * @returns a Promise that will resolve with the next value emitted.
-     */
-    awaitNext = (signal) => notifyEventToPromise(this.onEvent, signal);
-    /**
-     * The number of registered handlers.
-     */
-    get size() {
-        return this.#handlers.size;
-    }
-    /**
-     * Removes all registered handlers.
-     */
-    clear() {
-        this.#handlers.clear();
-    }
-    #onEvent(handler) {
-        if (this.#disposed) {
-            throw new AlreadyDisposedError();
-        }
-        const found = this.#handlers.get(handler);
-        if (found) {
-            return found;
-        }
-        let disposed = false;
-        const disposable = {
-            [Symbol.dispose]: () => {
-                if (disposed)
-                    return;
-                disposed = true;
-                this.#handlers.delete(handler);
-            },
-        };
-        this.#handlers.set(handler, disposable);
-        return disposable;
-    }
-    /**
-     * Notify all handlers of the event.
-     * @param value - The event value.
-     */
-    #notify(value) {
-        for (const handler of [...this.#handlers.keys()]) {
-            handler(value);
-        }
-    }
-    [Symbol.dispose]() {
-        if (this.#disposed)
-            return;
-        this.#disposed = true;
-        this.#handlers.clear();
-    }
-}
-/**
- * Convert a NotifyEvent to a Promise.
- * @param event - The event to convert.
- * @param signal - Optional AbortSignal to cancel the subscription if the promise is abandoned.
- * @returns A Promise that resolves with the first value emitted by the event.
- */
-export function notifyEventToPromise(event, signal) {
-    const once = notifyEventOnce(event);
-    return new Promise((resolve, reject) => {
-        signal?.throwIfAborted();
-        const disposable = once((value) => {
-            signal?.removeEventListener('abort', onAbort);
-            resolve(value);
-        });
-        function onAbort() {
-            disposable[Symbol.dispose]();
-            signal?.removeEventListener('abort', onAbort);
-            reject(signal?.reason);
-        }
-        signal?.addEventListener('abort', onAbort, { once: true });
-    });
-}
-/**
- * Create a NotifyEvent that only fires once.
- *
- * The same handler can be added multiple times and will be called once for each time it is added.
- * This is different from a normal NotifyEvent where the same handler is only added once.
- *
- * @param event - The event to wrap.
- * @returns A NotifyOnceEvent that only fires once for the handlers added.
- */
-export function notifyEventOnce(event) {
-    function notifyOnce(handler) {
-        const disposable = event((e) => {
-            // A NotifyEvent should register a handler, but never call it immediately.
-            // Therefore the disposable should always be defined here. A ReferenceError
-            // would indicate a bug in NotifyEmitter or NotifyEvent implementation.
-            disposable[Symbol.dispose]();
-            handler(e);
-        });
-        return disposable;
-    }
-    return notifyOnce;
-}
-//# sourceMappingURL=notify.js.map

package/dist/rpc/protocol.d.ts

@@ -1,21 +0,0 @@
-import type { OnlyFunctionsOrNever, StringKeyOf, ToReturnPromise } from './types.js';
-export type RPCProtocolMethods<T> = {
-    [K in StringKeyOf<T> as T[K] extends OnlyFunctionsOrNever<T[K]> ? K : never]: OnlyFunctionsOrNever<T[K]>;
-};
-export type RPCProtocol<T> = {
-    [K in StringKeyOf<T> as T[K] extends OnlyFunctionsOrNever<T[K]> ? K : never]: ToReturnPromise<OnlyFunctionsOrNever<T[K]>>;
-};
-export type RPCProtocolMethodNames<P> = StringKeyOf<RPCProtocol<P>>;
-/**
- * Cast the API methods to RPCProtocol.
- * @param methods - The API methods.
- * @returns the API methods as RPCProtocol.
- */
-export declare function protocolDefinition<API extends RPCProtocol<API>>(methods: API): RPCProtocol<API>;
-/**
- * Cast the API methods to RPCProtocolMethods.
- * @param apiMethods - The API methods.
- * @returns the API methods as RPCProtocolMethods.
- */
-export declare function protocolMethods<API extends RPCProtocolMethods<API>>(apiMethods: API): RPCProtocolMethods<API>;
-//# sourceMappingURL=protocol.d.ts.map

package/dist/rpc/protocol.js

@@ -1,17 +0,0 @@
-/**
- * Cast the API methods to RPCProtocol.
- * @param methods - The API methods.
- * @returns the API methods as RPCProtocol.
- */
-export function protocolDefinition(methods) {
-    return methods;
-}
-/**
- * Cast the API methods to RPCProtocolMethods.
- * @param apiMethods - The API methods.
- * @returns the API methods as RPCProtocolMethods.
- */
-export function protocolMethods(apiMethods) {
-    return apiMethods;
-}
-//# sourceMappingURL=protocol.js.map

package/dist/rpc/server.d.ts

@@ -1,39 +0,0 @@
-import type { MessagePortLike } from './messagePort.js';
-import type { RPCProtocol, RPCProtocolMethodNames } from './protocol.js';
-export interface RPCServerOptions {
-    /**
-     * If true, the server will close the message port when disposed.
-     * @default false
-     */
-    closePortOnDispose?: boolean;
-    /**
-     * If true, the server will respond with an error message for unknown or malformed requests.
-     * @default false
-     */
-    returnMalformedRPCRequestError?: boolean;
-}
-export interface RPCServerConfiguration extends RPCServerOptions {
-    /**
-     * The message port to use for communication.
-     */
-    port: MessagePortLike;
-}
-declare class RPCServerImpl<ServerApi, PApi extends RPCProtocol<ServerApi> = RPCProtocol<ServerApi>, MethodsNames extends RPCProtocolMethodNames<PApi> = RPCProtocolMethodNames<PApi>> {
-    #private;
-    constructor(config: RPCServerConfiguration, methods: ServerApi);
-    [Symbol.dispose](): void;
-}
-/**
- * RPC Server implementation.
- * @param ServerApi - The API methods of the server.
- */
-export declare class RPCServer<ServerApi> extends RPCServerImpl<ServerApi> {
-    /**
-     *
-     * @param config - The server configuration, including the message port and options.
-     * @param methods - The methods to implement the API.
-     */
-    constructor(config: RPCServerConfiguration, methods: ServerApi);
-}
-export {};
-//# sourceMappingURL=server.d.ts.map

package/dist/rpc/server.js

@@ -1,146 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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