cspell-trie-lib 7.0.0-alpha.2 → 7.0.0

package/dist/lib/Builder/BuilderCursor.d.ts

@@ -0,0 +1,7 @@
+export interface BuilderCursor {
+    insertChar(char: string): void;
+    markEOW(): void;
+    reference(nodeIdx: number): void;
+    backStep(num: number): void;
+}
+//# sourceMappingURL=BuilderCursor.d.ts.map

package/dist/lib/Builder/BuilderCursor.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/Builder/TrieBuilder.d.ts

@@ -0,0 +1,9 @@
+import type { PartialTrieOptions, TrieOptions } from '../trie.js';
+import type { TrieData } from '../TrieData.js';
+import type { BuilderCursor } from './BuilderCursor.js';
+export interface TrieBuilder<T extends TrieData> {
+    getCursor(): BuilderCursor;
+    build(): T;
+    setOptions(options: Readonly<PartialTrieOptions>): Readonly<TrieOptions>;
+}
+//# sourceMappingURL=TrieBuilder.d.ts.map

package/dist/lib/Builder/TrieBuilder.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/Builder/cursor-util.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderCursor } from './BuilderCursor.js';
+export declare function insertWordsAtCursor(cursor: BuilderCursor, words: Iterable<string>): void;
+//# sourceMappingURL=cursor-util.d.ts.map

package/dist/lib/Builder/cursor-util.js

@@ -0,0 +1,21 @@
+export function insertWordsAtCursor(cursor, words) {
+    let prevWord = '';
+    for (const word of words) {
+        const pLen = commonPrefixLen(prevWord, word);
+        const stepBack = prevWord.length - pLen;
+        cursor.backStep(stepBack);
+        for (let i = pLen; i < word.length; ++i) {
+            cursor.insertChar(word[i]);
+        }
+        cursor.markEOW();
+        prevWord = word;
+    }
+    cursor.backStep(prevWord.length);
+}
+function commonPrefixLen(a, b) {
+    let i = 0;
+    for (i = 0; i < a.length && a[i] === b[i]; ++i) {
+        /* empty */
+    }
+    return i;
+}

package/dist/lib/Builder/index.d.ts

@@ -0,0 +1,4 @@
+export type { BuilderCursor } from './BuilderCursor.js';
+export { insertWordsAtCursor } from './cursor-util.js';
+export type { TrieBuilder } from './TrieBuilder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Builder/index.js

@@ -0,0 +1 @@
+export { insertWordsAtCursor } from './cursor-util.js';

package/dist/lib/ITrie.d.ts

@@ -0,0 +1,164 @@
+import type { WeightMap } from './distance/index.js';
+import type { FindFullResult } from './ITrieNode/find.js';
+import type { ITrieNode } from './ITrieNode/index.js';
+import type { PartialTrieInfo, TrieInfo } from './ITrieNode/TrieInfo.js';
+import type { CompoundWordsMethod, WalkerIterator } from './ITrieNode/walker/walkerTypes.js';
+import type { SuggestionCollector, SuggestionResult } from './suggestCollector.js';
+import { type SuggestionOptions } from './suggestions/genSuggestionsOptions.js';
+import type { TrieData } from './TrieData.js';
+export interface ITrie {
+    readonly data: TrieData;
+    /**
+     * Approximate number of words in the Trie, the first call to this method might be expensive.
+     * Use `size` to get the number of nodes.
+     *
+     * It does NOT count natural compound words. Natural compounds are words that are composed of appending
+     * multiple words to make a new word. This is common in languages like German and Dutch.
+     */
+    numWords(): number;
+    /**
+     * Used to check if the number of words has been calculated.
+     */
+    isNumWordsKnown(): boolean;
+    /**
+     * The number of nodes in the Trie. There is a rough corelation between the size and the number of words.
+     */
+    readonly size: number;
+    readonly info: Readonly<TrieInfo>;
+    /**
+     * @param text - text to find in the Trie
+     */
+    find(text: string): ITrieNode | undefined;
+    has(word: string): boolean;
+    has(word: string, minLegacyCompoundLength: boolean | number): boolean;
+    /**
+     * Determine if a word is in the dictionary.
+     * @param word - the exact word to search for - must be normalized.
+     * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
+     * @returns true if the word was found and is not forbidden.
+     */
+    hasWord(word: string, caseSensitive: boolean): boolean;
+    findWord(word: string, options?: FindWordOptions): FindFullResult;
+    /**
+     * Determine if a word is in the forbidden word list.
+     * @param word the word to lookup.
+     */
+    isForbiddenWord(word: string): boolean;
+    /**
+     * Provides an ordered sequence of words with the prefix of text.
+     */
+    completeWord(text: string): Iterable<string>;
+    /**
+     * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+     * @param text - the text to search for
+     * @param options - Controls the generated suggestions:
+     * - ignoreCase - Ignore Case and Accents
+     * - numSuggestions - the maximum number of suggestions to return.
+     * - compoundMethod - Use to control splitting words.
+     * - changeLimit - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
+     *                      the lower the value, the faster results are returned. Values less than 4 are best.
+     */
+    suggest(text: string, options: SuggestionOptions): string[];
+    /**
+     * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+     * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
+     */
+    suggestWithCost(text: string, options: SuggestionOptions): SuggestionResult[];
+    /**
+     * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
+     * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
+     * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
+     */
+    genSuggestions(collector: SuggestionCollector, compoundMethod?: CompoundWordsMethod): void;
+    /**
+     * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
+     */
+    words(): Iterable<string>;
+    /**
+     * Allows iteration over the entire tree.
+     * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
+     */
+    iterate(): WalkerIterator;
+    weightMap: WeightMap | undefined;
+    get isCaseAware(): boolean;
+}
+export declare class ITrieImpl implements ITrie {
+    readonly data: TrieData;
+    private numNodes?;
+    private _info;
+    private _findOptionsDefaults;
+    private hasForbidden;
+    private root;
+    private count?;
+    weightMap: WeightMap | undefined;
+    constructor(data: TrieData, numNodes?: number | undefined);
+    /**
+     * Number of words in the Trie, the first call to this method might be expensive.
+     * Use `size` to get the number of nodes.
+     */
+    numWords(): number;
+    isNumWordsKnown(): boolean;
+    get size(): number;
+    get info(): Readonly<TrieInfo>;
+    get isCaseAware(): boolean;
+    /**
+     * @param text - text to find in the Trie
+     */
+    find(text: string): ITrieNode | undefined;
+    has(word: string, minLegacyCompoundLength?: boolean | number): boolean;
+    /**
+     * Determine if a word is in the dictionary.
+     * @param word - the exact word to search for - must be normalized.
+     * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
+     * @returns true if the word was found and is not forbidden.
+     */
+    hasWord(word: string, caseSensitive: boolean): boolean;
+    findWord(word: string, options?: FindWordOptions): FindFullResult;
+    /**
+     * Determine if a word is in the forbidden word list.
+     * @param word the word to lookup.
+     */
+    isForbiddenWord(word: string): boolean;
+    /**
+     * Provides an ordered sequence of words with the prefix of text.
+     */
+    completeWord(text: string): Iterable<string>;
+    /**
+     * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+     * @param text - the text to search for
+     * @param maxNumSuggestions - the maximum number of suggestions to return.
+     * @param compoundMethod - Use to control splitting words.
+     * @param numChanges - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
+     *                      the lower the value, the faster results are returned. Values less than 4 are best.
+     */
+    suggest(text: string, options: SuggestionOptions): string[];
+    /**
+     * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+     * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
+     */
+    suggestWithCost(text: string, options: SuggestionOptions): SuggestionResult[];
+    /**
+     * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
+     * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
+     * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
+     */
+    genSuggestions(collector: SuggestionCollector, compoundMethod?: CompoundWordsMethod): void;
+    /**
+     * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
+     */
+    words(): Iterable<string>;
+    /**
+     * Allows iteration over the entire tree.
+     * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
+     */
+    iterate(): WalkerIterator;
+    static create(words: Iterable<string> | IterableIterator<string>, info?: PartialTrieInfo): ITrie;
+    private createFindOptions;
+    private lastCreateFindOptionsMatchCaseMap;
+    private createFindOptionsMatchCase;
+}
+export interface FindWordOptions {
+    caseSensitive?: boolean;
+    useLegacyWordCompounds?: boolean | number;
+}
+//# sourceMappingURL=ITrie.d.ts.map

package/dist/lib/ITrie.js

@@ -0,0 +1,176 @@
+import { opAppend, opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
+import { createFindOptions, findLegacyCompound, findWord, findWordNode, isForbiddenWord } from './ITrieNode/find.js';
+import { countWords, iteratorTrieWords } from './ITrieNode/trie-util.js';
+import { walker } from './ITrieNode/walker/walker.js';
+import { createSuggestionOptions } from './suggestions/genSuggestionsOptions.js';
+import { genSuggestions, suggest } from './suggestions/suggestTrieData.js';
+import { FastTrieBlobBuilder } from './TrieBlob/FastTrieBlobBuilder.js';
+import { clean } from './utils/clean.js';
+import { mergeOptionalWithDefaults } from './utils/mergeOptionalWithDefaults.js';
+import { replaceAllFactory } from './utils/util.js';
+const defaultLegacyMinCompoundLength = 3;
+export class ITrieImpl {
+    constructor(data, numNodes) {
+        this.data = data;
+        this.numNodes = numNodes;
+        this.lastCreateFindOptionsMatchCaseMap = new Map();
+        this.root = data.getRoot();
+        this._info = mergeOptionalWithDefaults(data.info);
+        this.hasForbidden = data.hasForbiddenWords();
+        this._findOptionsDefaults = {
+            caseInsensitivePrefix: this._info.stripCaseAndAccentsPrefix,
+            compoundFix: this._info.compoundCharacter,
+            forbidPrefix: this._info.forbiddenWordPrefix,
+        };
+    }
+    /**
+     * Number of words in the Trie, the first call to this method might be expensive.
+     * Use `size` to get the number of nodes.
+     */
+    numWords() {
+        this.count ??= countWords(this.root);
+        return this.count;
+    }
+    isNumWordsKnown() {
+        return this.count !== undefined;
+    }
+    get size() {
+        return this.data.size;
+    }
+    get info() {
+        return this._info;
+    }
+    get isCaseAware() {
+        return this.info.isCaseAware ?? true;
+    }
+    /**
+     * @param text - text to find in the Trie
+     */
+    find(text) {
+        const options = this.createFindOptions({ compoundMode: 'compound' });
+        return findWordNode(this.data.getRoot(), text, options).node;
+    }
+    has(word, minLegacyCompoundLength) {
+        if (this.hasWord(word, false))
+            return true;
+        if (minLegacyCompoundLength) {
+            const f = this.findWord(word, { useLegacyWordCompounds: minLegacyCompoundLength });
+            return !!f.found;
+        }
+        return false;
+    }
+    /**
+     * Determine if a word is in the dictionary.
+     * @param word - the exact word to search for - must be normalized.
+     * @param caseSensitive - false means also searching a dictionary where the words were normalized to lower case and accents removed.
+     * @returns true if the word was found and is not forbidden.
+     */
+    hasWord(word, caseSensitive) {
+        const f = this.findWord(word, { caseSensitive });
+        return !!f.found && !f.forbidden;
+    }
+    findWord(word, options) {
+        if (options?.useLegacyWordCompounds) {
+            const len = options.useLegacyWordCompounds !== true
+                ? options.useLegacyWordCompounds
+                : defaultLegacyMinCompoundLength;
+            const findOptions = this.createFindOptions({
+                legacyMinCompoundLength: len,
+                matchCase: options.caseSensitive,
+            });
+            return findLegacyCompound(this.root, word, findOptions);
+        }
+        const findOptions = this.createFindOptionsMatchCase(options?.caseSensitive);
+        return findWord(this.root, word, findOptions);
+    }
+    /**
+     * Determine if a word is in the forbidden word list.
+     * @param word the word to lookup.
+     */
+    isForbiddenWord(word) {
+        return this.hasForbidden && isForbiddenWord(this.root, word, this.info.forbiddenWordPrefix);
+    }
+    /**
+     * Provides an ordered sequence of words with the prefix of text.
+     */
+    completeWord(text) {
+        const n = this.find(text);
+        const compoundChar = this.info.compoundCharacter;
+        const subNodes = pipe(n ? iteratorTrieWords(n) : [], opFilter((w) => w[w.length - 1] !== compoundChar), opMap((suffix) => text + suffix));
+        return pipe(n && n.eow ? [text] : [], opAppend(subNodes));
+    }
+    /**
+     * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+     * @param text - the text to search for
+     * @param maxNumSuggestions - the maximum number of suggestions to return.
+     * @param compoundMethod - Use to control splitting words.
+     * @param numChanges - the maximum number of changes allowed to text. This is an approximate value, since some changes cost less than others.
+     *                      the lower the value, the faster results are returned. Values less than 4 are best.
+     */
+    suggest(text, options) {
+        return this.suggestWithCost(text, options).map((a) => a.word);
+    }
+    /**
+     * Suggest spellings for `text`.  The results are sorted by edit distance with changes near the beginning of a word having a greater impact.
+     * The results include the word and adjusted edit cost.  This is useful for merging results from multiple tries.
+     */
+    suggestWithCost(text, options) {
+        const sep = options.compoundSeparator;
+        const weightMap = options.weightMap || this.weightMap;
+        const adjWord = sep ? replaceAllFactory(sep, '') : (a) => a;
+        const optFilter = options.filter;
+        const filter = optFilter
+            ? (word, cost) => {
+                const w = adjWord(word);
+                return !this.isForbiddenWord(w) && optFilter(w, cost);
+            }
+            : (word) => !this.isForbiddenWord(adjWord(word));
+        const opts = { ...options, filter, weightMap };
+        return suggest(this.data, text, opts);
+    }
+    /**
+     * genSuggestions will generate suggestions and send them to `collector`. `collector` is responsible for returning the max acceptable cost.
+     * Costs are measured in weighted changes. A cost of 100 is the same as 1 edit. Some edits are considered cheaper.
+     * Returning a MaxCost < 0 will effectively cause the search for suggestions to stop.
+     */
+    genSuggestions(collector, compoundMethod) {
+        const filter = (word) => !this.isForbiddenWord(word);
+        const options = createSuggestionOptions(clean({ compoundMethod, ...collector.genSuggestionOptions }));
+        const suggestions = genSuggestions(this.data, collector.word, options);
+        collector.collect(suggestions, undefined, filter);
+    }
+    /**
+     * Returns an iterator that can be used to get all words in the trie. For some dictionaries, this can result in millions of words.
+     */
+    words() {
+        return iteratorTrieWords(this.root);
+    }
+    /**
+     * Allows iteration over the entire tree.
+     * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
+     */
+    iterate() {
+        return walker(this.root);
+    }
+    static create(words, info) {
+        const builder = new FastTrieBlobBuilder(info);
+        builder.insert(words);
+        const root = builder.build();
+        return new ITrieImpl(root, undefined);
+    }
+    createFindOptions(options = {}) {
+        const findOptions = createFindOptions({
+            ...this._findOptionsDefaults,
+            ...options,
+        });
+        return findOptions;
+    }
+    createFindOptionsMatchCase(matchCase) {
+        const f = this.lastCreateFindOptionsMatchCaseMap.get(matchCase);
+        if (f !== undefined)
+            return f;
+        const findOptions = this.createFindOptions({ matchCase });
+        this.lastCreateFindOptionsMatchCaseMap.set(matchCase, findOptions);
+        return findOptions;
+    }
+}

package/dist/lib/ITrieNode/CompoundModes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * No compounding allowed.
+ */
+export type CompoundModeNone = 'none';
+/**
+ * Allow natural compounding in the dictionary
+ * using compound prefixes
+ */
+export type CompoundModesCompound = 'compound';
+/**
+ * Allow all possible compounds -- Very slow.
+ */
+export type CompoundModesLegacy = 'legacy';
+export type CompoundModes = CompoundModeNone | CompoundModesCompound | CompoundModesLegacy;
+//# sourceMappingURL=CompoundModes.d.ts.map

package/dist/lib/ITrieNode/CompoundModes.js

@@ -0,0 +1,4 @@
+/**
+ * No compounding allowed.
+ */
+export {};

package/dist/lib/ITrieNode/FindOptions.d.ts

@@ -0,0 +1,12 @@
+import type { PartialWithUndefined } from '../types.js';
+import type { CompoundModes } from './CompoundModes.js';
+export interface FindOptions {
+    matchCase: boolean;
+    compoundMode: CompoundModes;
+    forbidPrefix: string;
+    compoundFix: string;
+    caseInsensitivePrefix: string;
+    legacyMinCompoundLength: number;
+}
+export type PartialFindOptions = PartialWithUndefined<FindOptions> | undefined;
+//# sourceMappingURL=FindOptions.d.ts.map

package/dist/lib/ITrieNode/FindOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/ITrieNode/ITrieNode.d.ts

@@ -0,0 +1,42 @@
+import type { TrieInfo } from './TrieInfo.js';
+export type ITrieNodeId = object | number | string;
+type Entry = readonly [string, ITrieNode];
+export interface ITrieNode {
+    /**
+     * ITrieNode instances are not unique. It is possible for multiple ITrieNode instances to
+     * represent the same node.
+     * `id` is used to see if two instances refer to the same node.
+     * The type is obscured because it is up the the backing structure to provide the best value.
+     * Note, only nodes from the same root are guaranteed to be unique. It is possible for two
+     * different ITrieNode instances to have the same `id` value if they come from different roots.
+     */
+    readonly id: ITrieNodeId;
+    /** flag End of Word */
+    readonly eow: boolean;
+    /** number of children */
+    readonly size: number;
+    /** get keys to children */
+    keys(): readonly string[];
+    /** get keys to children */
+    values(): readonly ITrieNode[];
+    /** get the children as key value pairs */
+    entries(): readonly Entry[];
+    /** get child ITrieNode */
+    get(char: string): ITrieNode | undefined;
+    /** get a child by the key index */
+    child(idx: number): ITrieNode;
+    /** has child */
+    has(char: string): boolean;
+    /** `true` iff this node has children */
+    hasChildren(): boolean;
+}
+export interface ITrieNodeRoot extends ITrieNode {
+    info: Readonly<TrieInfo>;
+    /**
+     * converts an `id` into a node.
+     * @param id an of a ITrieNode in this Trie
+     */
+    resolveId(id: ITrieNodeId): ITrieNode;
+}
+export {};
+//# sourceMappingURL=ITrieNode.d.ts.map

package/dist/lib/ITrieNode/ITrieNode.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/ITrieNode/TrieInfo.d.ts

@@ -0,0 +1,9 @@
+import type { PartialWithUndefined } from '../types.js';
+export interface TrieInfo {
+    compoundCharacter: string;
+    stripCaseAndAccentsPrefix: string;
+    forbiddenWordPrefix: string;
+    isCaseAware: boolean;
+}
+export type PartialTrieInfo = PartialWithUndefined<TrieInfo> | undefined;
+//# sourceMappingURL=TrieInfo.d.ts.map

package/dist/lib/ITrieNode/TrieInfo.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/ITrieNode/find.d.ts

@@ -0,0 +1,48 @@
+import type { FindOptions, PartialFindOptions } from './FindOptions.js';
+import type { ITrieNode, ITrieNodeRoot } from './ITrieNode.js';
+type Root = ITrieNodeRoot;
+export interface FindNodeResult {
+    node: ITrieNode | undefined;
+}
+export interface FindResult {
+    found: string | false;
+    compoundUsed: boolean;
+    caseMatched: boolean;
+}
+export interface FindFullResult extends FindResult {
+    /**
+     * Is the word explicitly forbidden.
+     * - `true` - word is in the forbidden list.
+     * - `false` - word is not in the forbidden list.
+     * - `undefined` - unknown - was not checked.
+     * */
+    forbidden: boolean | undefined;
+}
+export interface FindFullNodeResult extends FindNodeResult, FindFullResult {
+}
+/**
+ *
+ * @param root Trie root node. root.c contains the compound root and forbidden root.
+ * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
+ * @param options
+ */
+export declare function findWord(root: Root, word: string, options?: PartialFindOptions): FindFullResult;
+/**
+ *
+ * @param root Trie root node. root.c contains the compound root and forbidden root.
+ * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
+ * @param options
+ */
+export declare function findWordNode(root: Root, word: string, options?: PartialFindOptions): FindFullNodeResult;
+export declare function findLegacyCompound(root: Root, word: string, options: FindOptions): FindFullNodeResult;
+export declare function findCompoundNode(root: Root | undefined, word: string, compoundCharacter: string, ignoreCasePrefix: string): FindFullNodeResult;
+export declare function findWordExact(root: Root | ITrieNode | undefined, word: string): boolean;
+export declare function isEndOfWordNode(n: ITrieNode | undefined): boolean;
+declare function findLegacyCompoundWord(roots: (ITrieNode | undefined)[], word: string, minCompoundLength: number): FindResult;
+export declare function isForbiddenWord(root: Root | ITrieNode | undefined, word: string, forbiddenPrefix: string): boolean;
+export declare const createFindOptions: (p: PartialFindOptions) => FindOptions;
+export declare const __testing__: {
+    findLegacyCompoundWord: typeof findLegacyCompoundWord;
+};
+export {};
+//# sourceMappingURL=find.d.ts.map