cspell-lib 9.4.0 → 9.6.1

package/dist/lib/textValidation/traceWord.js

@@ -7,6 +7,7 @@ export function traceWord(word, dictCollection, config) {
     const opts = {
         ignoreCase: config.ignoreCase ?? true,
         useCompounds: config.allowCompoundWords || false,
+        compoundSeparator: '•',
     };
     const splits = split({ text: word, offset: 0 }, 0, checkWord);
     const wfSplits = splits.words.map((s) => ({ word: s.text, found: s.isFound }));

package/dist/lib/trace.d.ts

@@ -1,5 +1,5 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { LanguageId } from './fileTypes.js';
 import type { DictionaryTraceResult, WordSplits } from './textValidation/traceWord.js';
 export interface TraceResult extends DictionaryTraceResult {
@@ -11,6 +11,7 @@ export interface TraceOptions {
     locale?: LocaleId;
     ignoreCase?: boolean;
     allowCompoundWords?: boolean;
+    compoundSeparator?: string | undefined;
 }
 export interface TraceWordResult extends Array<TraceResult> {
     splits: readonly WordSplits[];

package/dist/lib/trace.js

@@ -15,7 +15,7 @@ export async function traceWords(words, settings, options) {
     return s;
 }
 export async function* traceWordsAsync(words, settingsOrConfig, options) {
-    const { languageId, locale: language, ignoreCase = true, allowCompoundWords } = options || {};
+    const { languageId, locale: language, ignoreCase = true, allowCompoundWords, compoundSeparator } = options || {};
     const settings = satisfiesCSpellConfigFile(settingsOrConfig)
         ? await resolveConfigFileImports(settingsOrConfig)
         : settingsOrConfig;
@@ -44,7 +44,7 @@ export async function* traceWordsAsync(words, settingsOrConfig, options) {
     const { config, dicts, activeDictionaries } = await finalize(settings);
     const setOfActiveDicts = new Set(activeDictionaries);
     function processWord(word) {
-        const results = traceWord(word, dicts, { ...config, ignoreCase });
+        const results = traceWord(word, dicts, { ...config, ignoreCase, compoundSeparator });
         const r = results.map((r) => ({
             ...r,
             dictActive: setOfActiveDicts.has(r.dictName),

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/errors.js

@@ -26,7 +26,7 @@ export function isError(e) {
     if (!e || typeof e !== 'object')
         return false;
     const ex = e;
-    return typeof ex.name == 'string' && typeof ex.message == 'string' && (typeof ex.stack) in allowStringOrUndefined;
+    return typeof ex.name === 'string' && typeof ex.message === 'string' && (typeof ex.stack) in allowStringOrUndefined;
 }
 export function toError(e, errorFactory = UnknownError) {
     if (isError(e))

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

package/dist/rpc/assert.js

@@ -0,0 +1,21 @@
+/**
+ * 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 function assert(condition, msg) {
+    if (!condition) {
+        throw new AssertionError(msg);
+    }
+}
+export class AssertionError extends Error {
+    constructor(message) {
+        super(message || 'Assertion failed');
+        this.name = 'AssertionError';
+    }
+}
+//# sourceMappingURL=assert.js.map