cspell-lib 9.6.0 → 9.6.2

package/dist/lib/spellCheckFile.js

@@ -3,9 +3,11 @@ import { isBinaryDoc } from './Document/isBinaryDoc.js';
 import { documentToTextDocument, resolveDocument } from './Document/resolveDocument.js';
 import { createTextDocument } from './Models/TextDocument.js';
 import { createPerfTimer } from './perf/index.js';
+import { cloneSettingsForExport } from './Settings/sanitizeSettings.js';
 import { determineTextDocumentSettings } from './textValidation/determineTextDocumentSettings.js';
 import { DocumentValidator } from './textValidation/index.js';
 import { isError } from './util/errors.js';
+import { memoizeLastCall } from './util/memoizeLastCall.js';
 import { toUri } from './util/Uri.js';
 /**
  * Spell Check a file
@@ -73,6 +75,21 @@ export async function spellCheckDocument(document, options, settingsOrConfigFile
         };
     }
 }
+const memoizedCloneSettingsForExport = memoizeLastCall(cloneSettingsForExport);
+function sanitizeSettingsForExport(settings) {
+    return settings ? memoizedCloneSettingsForExport(settings) : {};
+}
+/**
+ * Spell Check a Document.
+ * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
+ * @param options - options to control checking
+ * @param settings - default settings to use.
+ */
+export async function spellCheckDocumentRPC(document, options, settingsOrConfigFile) {
+    const result = { ...(await spellCheckDocument(document, options, settingsOrConfigFile)) };
+    result.settingsUsed = sanitizeSettingsForExport(result.settingsUsed);
+    return result;
+}
 async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
     // if (options.skipValidation) {
     //     return {
@@ -95,17 +112,18 @@ async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
     Object.assign(perf, Object.fromEntries(Object.entries(docValidator.perfTiming).map(([k, v]) => ['_' + k, v])));
     const prep = docValidator._getPreparations();
     if (docValidator.errors.length) {
+        const settingsUsed = prep?.localConfig ||
+            (satisfiesCSpellConfigFile(settingsOrConfigFile) ? settingsOrConfigFile.settings : settingsOrConfigFile);
         return {
             document,
             options,
-            settingsUsed: prep?.localConfig ||
-                (satisfiesCSpellConfigFile(settingsOrConfigFile)
-                    ? settingsOrConfigFile.settings
-                    : settingsOrConfigFile),
+            settingsUsed,
             localConfigFilepath: prep?.localConfigFilepath,
             issues: [],
             checked: false,
             errors: docValidator.errors,
+            configErrors: docValidator.getConfigErrors(),
+            dictionaryErrors: docValidator.getDictionaryErrors(),
             perf,
         };
     }
@@ -121,6 +139,8 @@ async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
         issues,
         checked: docValidator.shouldCheckDocument(),
         errors: undefined,
+        configErrors: docValidator.getConfigErrors(),
+        dictionaryErrors: docValidator.getDictionaryErrors(),
         perf,
     };
     timer.end();

package/dist/lib/suggestions.js

@@ -4,7 +4,7 @@ import { finalizeSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSett
 import { calcSettingsForLanguageId, isValidLocaleIntlFormat, normalizeLocaleIntl, } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
 import { createAutoResolveCache } from './util/AutoResolve.js';
-import { memorizeLastCall } from './util/memorizeLastCall.js';
+import { memoizeLastCall } from './util/memoizeLastCall.js';
 import * as util from './util/util.js';
 const emptySuggestionOptions = Object.freeze({});
 const emptyCSpellSettings = Object.freeze({});
@@ -14,14 +14,14 @@ export async function* suggestionsForWords(words, options, settings) {
         yield await suggestionsForWord(word, options, cspellSettings);
     }
 }
-const memorizeSuggestions = memorizeLastCall(cacheSuggestionsForWord);
+const memoizeSuggestions = memoizeLastCall(cacheSuggestionsForWord);
 function cacheSuggestionsForWord(options, settings) {
     const cache = createAutoResolveCache();
     return (word) => cache.get(word, (word) => _suggestionsForWord(word, options, settings));
 }
 export async function suggestionsForWord(word, options = emptySuggestionOptions, settings = emptyCSpellSettings) {
     const cspellSettings = satisfiesCSpellConfigFile(settings) ? await resolveConfigFileImports(settings) : settings;
-    return memorizeSuggestions(options, cspellSettings)(word);
+    return memoizeSuggestions(options, cspellSettings)(word);
 }
 async function _suggestionsForWord(word, options, settings) {
     const { languageId, locale: language, includeDefaultConfig = true, dictionaries } = options;

package/dist/lib/textValidation/cleanValidationIssue.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationIssue } from '../Models/ValidationIssue.js';
+export declare function cleanValidationIssue(issue: ValidationIssue): ValidationIssue;
+//# sourceMappingURL=cleanValidationIssue.d.ts.map

package/dist/lib/textValidation/cleanValidationIssue.js

@@ -0,0 +1,21 @@
+import { cloneInto, copy0, copy1 } from '../util/clone.js';
+export function cleanValidationIssue(issue) {
+    const cleanIssue = {};
+    cloneInto(issue, cleanIssue, ValidationIssueHandlers);
+    return cleanIssue;
+}
+const ValidationIssueHandlers = {
+    text: copy0,
+    offset: copy0,
+    message: copy0,
+    line: copy1,
+    length: copy0,
+    issueType: copy0,
+    hasPreferredSuggestions: copy0,
+    hasSimpleSuggestions: copy0,
+    isFlagged: copy0,
+    isFound: copy0,
+    suggestions: copy1,
+    suggestionsEx: copy1,
+};
+//# sourceMappingURL=cleanValidationIssue.js.map

package/dist/lib/textValidation/determineTextDocumentSettings.d.ts

@@ -1,6 +1,6 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
-import type { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef.js';
 import type { TextDocument, TextDocumentRef } from '../Models/TextDocument.js';
+import type { CSpellSettingsInternal } from '../Settings/index.js';
 /**
  * Combines all relevant setting values into a final configuration to be used for spell checking.
  * It applies any overrides and appropriate language settings by taking into account the document type (languageId)

package/dist/lib/textValidation/docValidator.d.ts

@@ -1,9 +1,10 @@
 import type { CSpellUserSettings, MappedText, ParsedText } from '@cspell/cspell-types';
 import type { ICSpellConfigFile } from 'cspell-config-lib';
-import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef.js';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 import type { TextDocument, TextDocumentRef } from '../Models/TextDocument.js';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
+import type { ImportFileRefWithError } from '../Settings/index.js';
+import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Settings/index.js';
 import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
 import type { WordSuggestion } from '../suggestions.js';
 import type { MatchRange } from '../util/TextRange.js';
@@ -101,6 +102,8 @@ export declare class DocumentValidator {
     private genSuggestions;
     private adjustSuggestions;
     getFinalizedDocSettings(): CSpellSettingsInternal;
+    getConfigErrors(): ImportFileRefWithError[] | undefined;
+    getDictionaryErrors(): Map<string, Error[]> | undefined;
     /**
      * Returns true if the final result of the configuration calculation results
      * in the document being enabled. Note: in some cases, checking the document

package/dist/lib/textValidation/docValidator.js

@@ -13,6 +13,7 @@ import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
+import { cleanValidationIssue } from './cleanValidationIssue.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
@@ -245,7 +246,9 @@ export class DocumentValidator {
             const spellingIssues = forceCheck || this.shouldCheckDocument() ? [...this._checkParsedText(this._parse())] : [];
             const directiveIssues = this.checkDocumentDirectives();
             // console.log('Stats: %o', this._preparations.textValidator.lineValidator.dict.stats());
-            const allIssues = [...spellingIssues, ...directiveIssues].sort((a, b) => a.offset - b.offset);
+            const allIssues = [...spellingIssues, ...directiveIssues]
+                .map(cleanValidationIssue)
+                .sort((a, b) => a.offset - b.offset);
             return allIssues;
         }
         finally {
@@ -360,6 +363,20 @@ export class DocumentValidator {
         assert(this._preparations, ERROR_NOT_PREPARED);
         return this._preparations.docSettings;
     }
+    getConfigErrors() {
+        const settings = this.getFinalizedDocSettings();
+        const errors = extractImportErrors(settings);
+        return errors.length ? errors : undefined;
+    }
+    getDictionaryErrors() {
+        assert(this._ready);
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const { dictionary } = this._preparations;
+        const errors = dictionary.dictionaries
+            .map((dict) => [dict.name, dict.getErrors?.()])
+            .filter((entry) => (entry[1] && entry[1].length > 0) || false);
+        return errors.length ? new Map(errors) : undefined;
+    }
     /**
      * Returns true if the final result of the configuration calculation results
      * in the document being enabled. Note: in some cases, checking the document

package/dist/lib/textValidation/settingsToValidateOptions.d.ts

@@ -1,4 +1,4 @@
-import type { CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef.js';
+import type { CSpellSettingsInternalFinalized } from '../Settings/index.js';
 import type { ValidationOptions } from './ValidationTypes.js';
 export declare function settingsToValidateOptions(settings: CSpellSettingsInternalFinalized): ValidationOptions;
 //# sourceMappingURL=settingsToValidateOptions.d.ts.map

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

@@ -0,0 +1,35 @@
+export type Handler<T, K extends keyof T> = (src: Readonly<T>, dst: T, key: K) => void;
+export type Handlers<T> = {
+    [key in keyof T]-?: Handler<T, key>;
+};
+/**
+ * Clones the properties from src to dst using the provided handlers.
+ * @param src
+ * @param dst
+ * @param handlers
+ * @param keys
+ * @returns
+ */
+export declare function cloneInto<T, K extends keyof T>(src: Readonly<T>, dst: Partial<T>, handlers: Handlers<T>, keys?: K[]): Pick<T, K>;
+export declare function skip<T, K extends keyof T>(_src: Readonly<T>, _dst: T, _key: K): void;
+/**
+ * Copy the property from src to dst.
+ * If the property is undefined, it is not copied.
+ * @param src - source object
+ * @param dst - destination object
+ * @param key - property key
+ */
+export declare function copy0<T, K extends keyof T>(src: Readonly<T>, dst: T, key: K): void;
+/**
+ * Copy the property from src to dst.
+ * If the property is undefined, it is not copied.
+ * If the property is an array, a shallow copy of the array is made.
+ * If the property is a Set, a shallow copy of the Set is made.
+ * If the property is a Map, a shallow copy of the Map is made.
+ * If the property is an object, a shallow copy of the object is made.
+ * @param src - source object
+ * @param dst - destination object
+ * @param key - property key
+ */
+export declare function copy1<T, K extends keyof T>(src: Readonly<T>, dst: T, key: K): void;
+//# sourceMappingURL=clone.d.ts.map

package/dist/lib/util/clone.js

@@ -0,0 +1,76 @@
+/**
+ * Clones the properties from src to dst using the provided handlers.
+ * @param src
+ * @param dst
+ * @param handlers
+ * @param keys
+ * @returns
+ */
+export function cloneInto(src, dst, handlers, keys) {
+    const keysToProcess = keys || Object.keys(handlers);
+    for (const key of keysToProcess) {
+        if (src[key] === undefined)
+            continue;
+        const handler = handlers[key];
+        if (handler === skip)
+            continue;
+        handler(src, dst, key);
+    }
+    return dst;
+}
+export function skip(_src, _dst, _key) {
+    // do nothing
+}
+/**
+ * Copy the property from src to dst.
+ * If the property is undefined, it is not copied.
+ * @param src - source object
+ * @param dst - destination object
+ * @param key - property key
+ */
+export function copy0(src, dst, key) {
+    const value = src[key];
+    if (value === undefined)
+        return;
+    dst[key] = value;
+}
+/**
+ * Copy the property from src to dst.
+ * If the property is undefined, it is not copied.
+ * If the property is an array, a shallow copy of the array is made.
+ * If the property is a Set, a shallow copy of the Set is made.
+ * If the property is a Map, a shallow copy of the Map is made.
+ * If the property is an object, a shallow copy of the object is made.
+ * @param src - source object
+ * @param dst - destination object
+ * @param key - property key
+ */
+export function copy1(src, dst, key) {
+    if (src[key] === undefined)
+        return;
+    const value = src[key];
+    if (value === undefined)
+        return;
+    if (Array.isArray(value)) {
+        dst[key] = [...value];
+        return;
+    }
+    if (value instanceof Set) {
+        dst[key] = new Set(value);
+        return;
+    }
+    if (value instanceof Map) {
+        dst[key] = new Map(value);
+        return;
+    }
+    if (value instanceof RegExp) {
+        dst[key] = value;
+        return;
+    }
+    if (typeof value === 'object') {
+        dst[key] = { ...value };
+        return;
+    }
+    dst[key] = value;
+}
+//# sourceMappingURL=clone.js.map

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

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

package/dist/lib/util/{memorizeLastCall.js → memoizeLastCall.js}

@@ -1,5 +1,5 @@
 import { isArrayEqual } from './util.js';
-export function memorizeLastCall(fn) {
+export function memoizeLastCall(fn) {
     let last;
     return (...p) => {
         if (last && isArrayEqual(last.args, p)) {
@@ -11,4 +11,4 @@ export function memorizeLastCall(fn) {
         return value;
     };
 }
-//# sourceMappingURL=memorizeLastCall.js.map
+//# sourceMappingURL=memoizeLastCall.js.map

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

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

package/dist/lib/util/{memorizerWeak.js → memoizeWeak.js}

@@ -1,5 +1,5 @@
 // prettier-ignore
-export function memorizerWeak(fn) {
+export function memoizeWeak(fn) {
     const r = {};
     function find(p) {
         let n = r;
@@ -35,4 +35,4 @@ export function memorizerWeak(fn) {
         return v;
     };
 }
-//# sourceMappingURL=memorizerWeak.js.map
+//# sourceMappingURL=memoizeWeak.js.map

package/dist/lib/util/text.js

@@ -27,7 +27,7 @@ export function splitWordWithOffset(wo, regExpWordBreaks) {
  * Split camelCase words into an array of strings.
  */
 export function splitWord(word, regExpWordBreaks) {
-    return word.split(regExpWordBreaks);
+    return word.split(new RegExp(regExpWordBreaks));
 }
 /**
  * This function lets you iterate over regular expression matches.
@@ -35,7 +35,7 @@ export function splitWord(word, regExpWordBreaks) {
 export function match(reg, text) {
     if (!text)
         return [];
-    reg = reg.global ? reg : new RegExp(reg.source, reg.flags + 'g');
+    reg = reg.global ? new RegExp(reg) : new RegExp(reg.source, reg.flags + 'g');
     return text.matchAll(reg);
 }
 export function matchStringToTextOffset(reg, text) {
@@ -78,6 +78,7 @@ export function cleanText(text) {
     regExIgnoreCharacters.lastIndex = 0;
     if (!regExIgnoreCharacters.test(text))
         return text;
+    regExIgnoreCharacters.lastIndex = 0;
     text = text.replace(regExIgnoreCharacters, (match) => ' '.repeat(match.length));
     return text;
 }
@@ -191,10 +192,11 @@ export function calculateTextDocumentOffsets(uri, doc, wordOffsets) {
     });
 }
 export function removeAccents(text) {
+    regExAccents.lastIndex = 0;
     return text.normalize('NFD').replace(regExAccents, '');
 }
 export const __testing__ = {
-    regExWords,
-    regExWordsAndDigits,
+    regExWords: regExWords,
+    regExWordsAndDigits: regExWordsAndDigits,
 };
 //# sourceMappingURL=text.js.map

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

@@ -2,8 +2,8 @@ export declare const regExUpperSOrIng: RegExp;
 export declare const regExSplitWords: RegExp;
 export declare const regExSplitWords2: RegExp;
 export declare const regExpCamelCaseWordBreaksWithEnglishSuffix: RegExp;
-export declare const regExpCamelCaseWordBreaks: RegExp;
-export declare const regExpAllPossibleWordBreaks: RegExp;
+export declare const regExpCamelCaseWordBreaks_NOT_USED: RegExp;
+export declare const regExpAllPossibleWordBreaks_NOT_USED: RegExp;
 export declare const regExWords: RegExp;
 export declare const regExWordsAndDigits: RegExp;
 export declare const regExIgnoreCharacters: RegExp;

package/dist/lib/util/textRegex.js

@@ -3,8 +3,8 @@ export const regExUpperSOrIng = /([\p{Lu}\p{M}]+(?:\\?['’])?(?:s|ing|ies|es|in
 export const regExSplitWords = /(\p{Ll}\p{M}?)(\p{Lu})/gu;
 export const regExSplitWords2 = /(\p{Lu}\p{M}?)((\p{Lu}\p{M}?)\p{Ll})/gu;
 export const regExpCamelCaseWordBreaksWithEnglishSuffix = /(?<=\p{Ll}\p{M}?)(?=\p{Lu})|(?<=\p{Lu}\p{M}?)(?=\p{Lu}\p{M}?\p{Ll})(?!\p{Lu}\p{M}?(?:s|ing|ies|es|ings|ed|ning)(?!\p{Ll}))/gu;
-export const regExpCamelCaseWordBreaks = /(?<=\p{Ll}\p{M}?)(?=\p{Lu})|(?<=\p{Lu}\p{M}?)(?=\p{Lu}\p{M}?\p{Ll})/gu;
-export const regExpAllPossibleWordBreaks = /(?<=\p{Ll}\p{M}?)(?=\p{Lu})|(?<=\p{Lu}\p{M}?)(?=\p{Lu}\p{M}?\p{Ll})|(?<=\p{Lu}\p{M}?\p{Lu}\p{M}?)(?=\p{Ll})|(?<=\p{L}\p{M}?)(?=\P{L})|(?<=\P{L})(?=\p{L})/gu;
+export const regExpCamelCaseWordBreaks_NOT_USED = /(?<=\p{Ll}\p{M}?)(?=\p{Lu})|(?<=\p{Lu}\p{M}?)(?=\p{Lu}\p{M}?\p{Ll})/gu;
+export const regExpAllPossibleWordBreaks_NOT_USED = /(?<=\p{Ll}\p{M}?)(?=\p{Lu})|(?<=\p{Lu}\p{M}?)(?=\p{Lu}\p{M}?\p{Ll})|(?<=\p{Lu}\p{M}?\p{Lu}\p{M}?)(?=\p{Ll})|(?<=\p{L}\p{M}?)(?=\P{L})|(?<=\P{L})(?=\p{L})/gu;
 export const regExWords = /\p{L}\p{M}?(?:(?:\\?['’])?\p{L}\p{M}?)*/gu;
 // Words can be made of letters, numbers, period, underscore, dash, plus, and single quote
 export const regExWordsAndDigits = /[\p{L}\w'’`.+-](?:(?:\\(?=[']))?[\p{L}\p{M}\w'’`.+-])*/gu;

package/dist/rpc/Future.d.ts

@@ -0,0 +1,18 @@
+export declare class Future<T> {
+    #private;
+    constructor();
+    /**
+     * Indicates if the promise has been resolved or rejected.
+     *
+     * Use isRejected to determine if it was rejected.
+     */
+    get isResolved(): boolean;
+    /**
+     * Indicates if the promise has been rejected.
+     */
+    get isRejected(): boolean;
+    get promise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: unknown): void;
+}
+//# sourceMappingURL=Future.d.ts.map

package/dist/rpc/Future.js

@@ -0,0 +1,49 @@
+export class Future {
+    #isResolved = false;
+    #isRejected = false;
+    #promise;
+    #resolve;
+    #reject;
+    constructor() {
+        this.#reject = noop;
+        this.#resolve = noop;
+        this.#promise = new Promise((resolve, reject) => {
+            this.#resolve = resolve;
+            this.#reject = reject;
+        });
+    }
+    /**
+     * Indicates if the promise has been resolved or rejected.
+     *
+     * Use isRejected to determine if it was rejected.
+     */
+    get isResolved() {
+        return this.#isResolved;
+    }
+    /**
+     * Indicates if the promise has been rejected.
+     */
+    get isRejected() {
+        return this.#isRejected;
+    }
+    get promise() {
+        return this.#promise;
+    }
+    resolve(value) {
+        if (this.#isResolved)
+            return;
+        this.#isResolved = true;
+        this.#resolve(value);
+    }
+    reject(reason) {
+        if (this.#isResolved)
+            return;
+        this.#isResolved = true;
+        this.#isRejected = true;
+        this.#reject(reason);
+    }
+}
+function noop() {
+    // do nothing
+}
+//# sourceMappingURL=Future.js.map

package/dist/rpc/MessagePortEvents.d.ts

@@ -0,0 +1,56 @@
+import type { MessagePortLike } from './messagePort.js';
+import type { NotifyEvent } from './notify.js';
+/**
+ * Wraps a {@link MessagePortLike} and exposes its key events through a
+ * {@link NotifyEmitter}-based interface.
+ *
+ * This class listens to the underlying port's `message`,
+ * `messageerror`, and `close` events and re-emits them as
+ * {@link NotifyEvent} instances, making it easier to subscribe to and manage
+ * notifications from a message port.
+ */
+export declare class MessagePortNotifyEvents<T extends MessagePortLike = MessagePortLike> {
+    #private;
+    constructor(port: T);
+    [Symbol.dispose](): void;
+    /**
+     * Register a handler to be called when a message is received.
+     */
+    get onMessage(): NotifyEvent<unknown>;
+    /**
+     * Return a Promise that resolves on the next message.
+     * @param signal - A signal to abort the wait.
+     * @returns A Promise that resolves with the next message received.
+     */
+    readonly awaitNextMessage: (signal?: AbortSignal) => Promise<unknown>;
+    /**
+     * Return a Promise that resolves on the close event.
+     * @param signal - A signal to abort the wait.
+     * @returns A Promise that resolves when the port is closed.
+     */
+    readonly awaitClose: (signal?: AbortSignal) => Promise<Event>;
+    /**
+     * Post a message to the underlying port.
+     * @param message - The message to post.
+     */
+    readonly postMessage: T['postMessage'];
+    /**
+     * Start the underlying port.
+     */
+    start(): void;
+    /**
+     * Close the underlying port.
+     */
+    close(): void;
+    /**
+     * Register a handler to be called when the port is closed.
+     */
+    get onClose(): NotifyEvent<Event>;
+    /**
+     * Register a handler to be called when a message error is received.
+     */
+    get onMessageError(): NotifyEvent<Error>;
+    get isClosed(): boolean;
+    get port(): T;
+}
+//# sourceMappingURL=MessagePortEvents.d.ts.map

package/dist/rpc/MessagePortEvents.js

@@ -0,0 +1,94 @@
+import { NotifyEmitter } from './notify.js';
+/**
+ * Wraps a {@link MessagePortLike} and exposes its key events through a
+ * {@link NotifyEmitter}-based interface.
+ *
+ * This class listens to the underlying port's `message`,
+ * `messageerror`, and `close` events and re-emits them as
+ * {@link NotifyEvent} instances, making it easier to subscribe to and manage
+ * notifications from a message port.
+ */
+export class MessagePortNotifyEvents {
+    #notifyMessage = new NotifyEmitter();
+    #notifyClose = new NotifyEmitter();
+    #notifyMessageError = new NotifyEmitter();
+    #port;
+    #disposed = false;
+    #closed;
+    constructor(port) {
+        this.#port = port;
+        this.#port.addListener('message', this.#notifyMessage.notify);
+        this.#port.addListener('messageerror', this.#notifyMessageError.notify);
+        this.#port.addListener('close', this.#notifyClose.notify);
+        this.#notifyClose.once((event) => (this.#closed = event));
+    }
+    [Symbol.dispose]() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#port.removeListener('message', this.#notifyMessage.notify);
+        this.#port.removeListener('messageerror', this.#notifyMessageError.notify);
+        this.#port.removeListener('close', this.#notifyClose.notify);
+        this.#notifyMessage[Symbol.dispose]();
+        this.#notifyClose[Symbol.dispose]();
+        this.#notifyMessageError[Symbol.dispose]();
+    }
+    /**
+     * Register a handler to be called when a message is received.
+     */
+    get onMessage() {
+        return this.#notifyMessage.onEvent;
+    }
+    /**
+     * Return a Promise that resolves on the next message.
+     * @param signal - A signal to abort the wait.
+     * @returns A Promise that resolves with the next message received.
+     */
+    awaitNextMessage = (signal) => this.#notifyMessage.awaitNext(signal);
+    /**
+     * Return a Promise that resolves on the close event.
+     * @param signal - A signal to abort the wait.
+     * @returns A Promise that resolves when the port is closed.
+     */
+    awaitClose = (signal) => {
+        if (this.#closed)
+            return Promise.resolve(this.#closed);
+        return this.#notifyClose.awaitNext(signal);
+    };
+    /**
+     * Post a message to the underlying port.
+     * @param message - The message to post.
+     */
+    postMessage = (message) => this.#port.postMessage(message);
+    /**
+     * Start the underlying port.
+     */
+    start() {
+        this.#port.start?.();
+    }
+    /**
+     * Close the underlying port.
+     */
+    close() {
+        this.#port.close?.();
+    }
+    /**
+     * Register a handler to be called when the port is closed.
+     */
+    get onClose() {
+        return this.#notifyClose.onEvent;
+    }
+    /**
+     * Register a handler to be called when a message error is received.
+     */
+    get onMessageError() {
+        return this.#notifyMessageError.onEvent;
+    }
+    get isClosed() {
+        return this.#closed !== undefined;
+    }
+    get port() {
+        return this.#port;
+    }
+}
+//# sourceMappingURL=MessagePortEvents.js.map

package/dist/rpc/assert.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Note: This code is here to avoid a dependency on Node's 'assert' module.
+ */
+/**
+ * Asserts that a condition is true.
+ * @param condition - The condition to assert.
+ * @param msg - optional message for the assertion error.
+ * @throws {AssertionError} If the condition is false.
+ */
+export declare function assert(condition: unknown, msg?: string): asserts condition;
+export declare class AssertionError extends Error {
+    constructor(message?: string);
+}
+//# sourceMappingURL=assert.d.ts.map