fix: Support string prefixes when walking nodes

packages/cspell-trie-lib/src/lib/StringTable/StringTable.ts

@@ -57,12 +57,13 @@ export class StringTable {
         return this.#strLenBits;
     }
 
-    getStringBytes(idx: number): Uint8Array | undefined {
+    get length(): number {
+        return this.#index.length;
+    }
+
+    getStringBytes(idx: number): U8Array | undefined {
         if (idx < 0 || idx >= this.#index.length) return undefined;
-        const value = this.#index[idx];
-        const offset = value >>> this.#strLenBits;
-        const length = value & this.#strLenMask;
-        return this.#data.subarray(offset, offset + length);
+        return this.#getBytesByIndexValue(this.#index[idx]);
     }
 
     getString(idx: number): string | undefined {
@@ -71,6 +72,16 @@ export class StringTable {
         return this.#decoder.decode(bytes);
     }
 
+    #getBytesByIndexValue(value: number): U8Array {
+        const offset = value >>> this.#strLenBits;
+        const length = value & this.#strLenMask;
+        return this.#data.subarray(offset, offset + length);
+    }
+
+    values(): U8Array[] {
+        return [...this.#index].map((v) => this.#getBytesByIndexValue(v));
+    }
+
     toString(): string {
         return [...this.#index].map((_, i) => this.getString(i) || '').join(', ');
     }
@@ -85,7 +96,7 @@ export class StringTable {
 }
 
 export class StringTableBuilder {
-    #buffers: (number[] | Uint8Array)[] = [];
+    #data: (number[] | Uint8Array)[] = [];
     #encoder = new TextEncoder();
     #lookupTrie = new GTrie<number, number>();
     #locked = false;
@@ -97,7 +108,7 @@ export class StringTableBuilder {
         if (found !== undefined) {
             return found;
         }
-        const idx = this.#buffers.push(bytes) - 1;
+        const idx = this.#data.push(bytes) - 1;
         this.#lookupTrie.insert(bytes, idx);
         this.#maxStrLen = Math.max(this.#maxStrLen, bytes.length);
         return idx;
@@ -108,20 +119,28 @@ export class StringTableBuilder {
         return this.addStringBytes(bytes);
     }
 
+    getEntry(idx: number): number[] | Uint8Array | undefined {
+        return this.#data[idx];
+    }
+
+    get length(): number {
+        return this.#data.length;
+    }
+
     build(): StringTable {
         this.#locked = true;
 
-        if (!this.#buffers.length) {
+        if (!this.#data.length) {
             return new StringTable([], new Uint8Array(0), 8);
         }
 
         // sorted by size descending
-        const sortedBySize = this.#buffers.map((b, i) => ({ b, i })).sort((a, b) => b.b.length - a.b.length);
+        const sortedBySize = this.#data.map((b, i) => ({ b, i })).sort((a, b) => b.b.length - a.b.length);
         const byteValues: number[] = [];
 
         const strLenBits = Math.ceil(Math.log2(this.#maxStrLen + 1));
         const strLenMask = (1 << strLenBits) - 1;
-        const index: number[] = new Array(this.#buffers.length);
+        const index: number[] = new Array(this.#data.length);
 
         for (const { b, i } of sortedBySize) {
             let offset = findValues(b);
@@ -162,6 +181,17 @@ export class StringTableBuilder {
             return offset;
         }
     }
+
+    static fromStringTable(table: StringTable): StringTableBuilder {
+        const builder = new StringTableBuilder();
+        const values = table.values();
+        const len = values.length;
+        for (let i = 0; i < len; ++i) {
+            builder.addStringBytes(values[i]);
+        }
+
+        return builder;
+    }
 }
 
 function getStringTableBinaryFormat(): BinaryFormat {
@@ -176,7 +206,7 @@ function getStringTableBinaryFormat(): BinaryFormat {
         .build();
 }
 
-export function encodeStringTableToBinary(table: StringTable, endian: 'LE' | 'BE'): U8Array {
+export function encodeStringTableToBinary(table: StringTable, endian?: 'LE' | 'BE'): U8Array {
     const strLenBits = table.strLenBits;
     const offsetBits = Math.ceil(Math.log2(table.charData.length + 1));
     const minIndexBits = strLenBits + offsetBits;
@@ -198,7 +228,10 @@ export function encodeStringTableToBinary(table: StringTable, endian: 'LE' | 'BE
     return builder.build();
 }
 
-export function decodeStringTableFromBinary(data: U8Array, endian: 'LE' | 'BE'): StringTable {
+export function decodeStringTableFromBinary(data: U8Array, endian?: 'LE' | 'BE'): StringTable {
+    if (!data?.length) {
+        return new StringTable([], new Uint8Array(0), 8);
+    }
     const reader = new BinaryDataReader(data, getStringTableBinaryFormat(), endian);
     const indexBits = reader.getUint8('indexBits');
     const strLenBits = reader.getUint8('strLenBits');

packages/cspell-trie-lib/src/lib/TrieBlob/FastTrieBlob.test.ts

@@ -111,9 +111,9 @@ describe('optimization', async () => {
     test('English Dict', () => {
         const trie = trieEn;
         const ft = FastTrieBlobBuilder.fromTrieRoot(trie.root, false);
-        const ft2 = FastTrieBlobBuilder.fromTrieRoot(trie.root, true);
-        expect(ft2.size).toBeLessThanOrEqual(ft.size);
-        expect([...ft.words()]).toEqual([...ft2.words()]);
+        const tb = FastTrieBlobBuilder.fromTrieRoot(trie.root, true);
+        expect(tb.size).toBeLessThanOrEqual(ft.size);
+        expect([...tb.words()]).toEqual([...ft.words()]);
     });
 });
 
@@ -129,15 +129,10 @@ describe('Using String Tables', async () => {
         const trie = trieEn;
         const ft = FastTrieBlobBuilder.fromTrieRoot(trie.root, false);
         const ft2 = FastTrieBlobBuilder.fromTrieRoot(trie.root, true);
-        console.log(`English Dict: Original Size: ${ft.size}, Optimized Size: ${ft2.size}`);
-
-        const stringTable = ft2.testExtractStringTable();
-        // console.log(`String Table Size: ${stringTable.charData.length} bytes for ${stringTable.index.length} strings.`);
-        // console.log('%s', hexDump(stringTable.charData));
-        expect(stringTable.getString(0)).toBeDefined();
+        // console.log(`English Dict: Original Size: ${ft.size}, Optimized Size: ${ft2.size}`);
 
         expect(ft2.size).toBeLessThan(ft.size);
-        expect([...ft.words()]).toEqual([...ft2.words()]);
+        expect([...ft2.words()]).toEqual([...ft.words()]);
     });
 });
 

packages/cspell-trie-lib/src/lib/TrieBlob/FastTrieBlob.ts

@@ -8,9 +8,15 @@ import { CharIndex } from './CharIndex.ts';
 import type { FastTrieBlobInternals } from './FastTrieBlobInternals.ts';
 import { assertSorted, FastTrieBlobInternalsAndMethods, sortNodes } from './FastTrieBlobInternals.ts';
 import { FastTrieBlobIRoot } from './FastTrieBlobIRoot.ts';
-import { extractStringTable } from './optimizeNodes.ts';
 import { TrieBlob } from './TrieBlob.ts';
-import { NodeChildIndexRefShift, NodeHeaderEOWMask, NodeMaskCharByte, type TrieBlobNode32 } from './TrieBlobFormat.ts';
+import {
+    NodeChildIndexRefShift,
+    NodeHeaderEOWMask,
+    NodeHeaderNumChildrenMask,
+    NodeHeaderPrefixShift,
+    NodeMaskCharByte,
+    type TrieBlobNode32,
+} from './TrieBlobFormat.ts';
 import { Utf8Accumulator } from './Utf8.ts';
 
 type FastTrieBlobNode = TrieBlobNode32;
@@ -30,11 +36,13 @@ export class FastTrieBlob implements TrieData {
     readonly hasNonStrictWords: boolean;
     readonly hasPreferredSuggestions: boolean;
     #nodes: FastTrieBlobNode[];
+    #stringTable: StringTable;
     #charIndex: CharIndex;
     readonly info: Readonly<TrieInfo>;
 
-    private constructor(nodes: FastTrieBlobNode[], info: Readonly<TrieInfo>) {
+    private constructor(nodes: FastTrieBlobNode[], stringTable: StringTable, info: Readonly<TrieInfo>) {
         this.#nodes = nodes;
+        this.#stringTable = stringTable;
         this.#charIndex = new CharIndex();
         this.info = info;
         this.wordToCharacters = (word: string) => [...word];
@@ -141,18 +149,23 @@ export class FastTrieBlob implements TrieData {
             nodeIdx: number;
             pos: number;
             word: string;
-            accumulator: Utf8Accumulator;
+            acc: Utf8Accumulator;
         }
         const nodeMaskChildCharIndex = NodeMaskCharByte;
         const nodeChildRefShift = NodeChildIndexRefShift;
         const NodeMaskEOW = NodeHeaderEOWMask;
+        const pfxShift = NodeHeaderPrefixShift;
         const nodes = this.#nodes;
-        const accumulator = Utf8Accumulator.create();
-        const stack: StackItem[] = [{ nodeIdx: rootIdx, pos: 0, word: '', accumulator }];
+        const st = this.#stringTable;
+        const stack: StackItem[] = [{ nodeIdx: rootIdx, pos: 0, word: '', acc: Utf8Accumulator.create() }];
         let depth = 0;
 
         while (depth >= 0) {
-            const { nodeIdx, pos, word, accumulator } = stack[depth];
+            const s = stack[depth];
+            if (!s.pos) {
+                applyPrefixString(s);
+            }
+            const { nodeIdx, pos, word, acc } = s;
             const node = nodes[nodeIdx];
 
             if (!pos && node[0] & NodeMaskEOW) {
@@ -165,17 +178,28 @@ export class FastTrieBlob implements TrieData {
             const nextPos = ++stack[depth].pos;
             const entry = node[nextPos];
             const charIdx = entry & nodeMaskChildCharIndex;
-            const acc = accumulator.clone();
-            const codePoint = acc.decode(charIdx);
+            const nAcc = acc.clone();
+            const codePoint = nAcc.decode(charIdx);
             const letter = (codePoint && String.fromCodePoint(codePoint)) || '';
             ++depth;
             stack[depth] = {
                 nodeIdx: entry >>> nodeChildRefShift,
                 pos: 0,
                 word: word + letter,
-                accumulator: acc,
+                acc: nAcc,
             };
         }
+
+        function applyPrefixString(s: StackItem): void {
+            const prefixIdx = nodes[s.nodeIdx][0] >>> pfxShift;
+            const pfx = prefixIdx ? st.getStringBytes(prefixIdx) : undefined;
+            if (!pfx) return;
+            s.word += s.acc.decodeBytesToString(pfx);
+        }
+    }
+
+    get stringTable(): StringTable {
+        return this.#stringTable;
     }
 
     toTrieBlob(): TrieBlob {
@@ -203,7 +227,7 @@ export class FastTrieBlob implements TrieData {
         for (let i = 0; i < nodes.length; ++i) {
             const node = nodes[i];
             // assert(offset === nodeToIndex[i]);
-            binNodes[offset++] = ((node.length - 1) << lenShift) | node[0];
+            binNodes[offset++] = ((node.length - 1) << lenShift) | (node[0] & ~NodeHeaderNumChildrenMask);
             for (let j = 1; j < node.length; ++j) {
                 const v = node[j];
                 const nodeRef = v >>> nodeChildRefShift;
@@ -212,7 +236,7 @@ export class FastTrieBlob implements TrieData {
             }
         }
 
-        return new TrieBlob(binNodes, this.info);
+        return new TrieBlob(binNodes, this.#stringTable, this.info);
     }
 
     isReadonly(): boolean {
@@ -240,12 +264,12 @@ export class FastTrieBlob implements TrieData {
     }
 
     static create(data: FastTrieBlobInternals): FastTrieBlob {
-        return new FastTrieBlob(data.nodes, data.info);
+        return new FastTrieBlob(data.nodes, data.stringTable, data.info);
     }
 
     static toITrieNodeRoot(trie: FastTrieBlob): ITrieNodeRoot {
         return new FastTrieBlobIRoot(
-            new FastTrieBlobInternalsAndMethods(trie.#nodes, trie.info, {
+            new FastTrieBlobInternalsAndMethods(trie.#nodes, trie.#stringTable, trie.info, {
                 nodeFindNode: (idx: number, word: string) => trie.#lookupNode(idx, trie.wordToUtf8Seq(word)),
                 nodeFindExact: (idx: number, word: string) => trie.#has(idx, word),
                 nodeGetChild: (idx: number, letter: string) => trie.#searchNodeForChar(idx, letter),
@@ -345,16 +369,12 @@ export class FastTrieBlob implements TrieData {
                 node[j] = (idx << TrieBlob.NodeChildRefShift) | charIndex;
             }
         }
-        return new FastTrieBlob(sortNodes(nodes, TrieBlob.NodeMaskChildCharIndex), trie.info);
+        return new FastTrieBlob(sortNodes(nodes, TrieBlob.NodeMaskChildCharIndex), trie.stringTable, trie.info);
     }
 
     static isFastTrieBlob(obj: unknown): obj is FastTrieBlob {
         return obj instanceof FastTrieBlob;
     }
-
-    testExtractStringTable(): StringTable {
-        return extractStringTable(this.#nodes);
-    }
 }
 
 interface TrieBlobNodeInfo {

packages/cspell-trie-lib/src/lib/TrieBlob/FastTrieBlobBuilder.test.ts

@@ -159,7 +159,7 @@ describe('FastTrieBlobBuilder', () => {
         const words = sampleWords();
         const t = FastTrieBlobBuilder.fromTrieRoot(buildTrie(words, false), true);
         const sortedUnique = [...new Set(words)].sort();
-        expect([...t.words()].sort()).toEqual(sortedUnique);
+        expect([...t.words()]).toEqual(sortedUnique);
     });
 
     test('fromTrieRoot optimized trie', () => {

packages/cspell-trie-lib/src/lib/TrieBlob/FastTrieBlobBuilder.ts

@@ -1,14 +1,15 @@
 import type { BuilderCursor, TrieBuilder } from '../Builder/index.ts';
 import type { PartialTrieInfo, TrieCharacteristics, TrieInfo } from '../ITrieNode/TrieInfo.ts';
 import { TrieInfoBuilder } from '../ITrieNode/TrieInfo.ts';
+import { StringTableBuilder } from '../StringTable/StringTable.ts';
 import type { TrieNode, TrieRoot } from '../TrieNode/TrieNode.ts';
 import { assert } from '../utils/assert.ts';
 import { assertValidUtf16Character } from '../utils/text.ts';
 import { CharIndexBuilder } from './CharIndex.ts';
 import type { NodeToJSON } from './FastTrieBlob.ts';
 import { FastTrieBlob, nodesToJSON } from './FastTrieBlob.ts';
 import { FastTrieBlobInternals, sortNodes } from './FastTrieBlobInternals.ts';
-import { optimizeNodes } from './optimizeNodes.ts';
+import { optimizeNodesWithStringTable } from './optimizeNodes.ts';
 import { resolveMap } from './resolveMap.ts';
 import { TrieBlob } from './TrieBlob.ts';
 import { NodeChildIndexRefShift, NodeHeaderEOWMask, NodeMaskCharByte } from './TrieBlobFormat.ts';
@@ -241,8 +242,8 @@ export class FastTrieBlobBuilder implements TrieBuilder<FastTrieBlob> {
         const wLen = word.length;
         const bytes: number[] = [];
 
-        for (const t = { text: word, offset: 0 }; t.offset < wLen; ) {
-            const isLastChar = t.offset >= wLen - 1;
+        for (const t = { text: word, i: 0 }; t.i < wLen; ) {
+            const isLastChar = t.i >= wLen - 1;
             for (let utf8Code = encodeTextToUtf8_32Rev(t); utf8Code; utf8Code >>>= 8) {
                 const seq = utf8Code & 0xff;
                 bytes.push(seq);
@@ -336,9 +337,13 @@ export class FastTrieBlobBuilder implements TrieBuilder<FastTrieBlob> {
             NodeMaskCharByte,
         );
 
-        const nodes = optimize ? optimizeNodes(sortedNodes) : sortedNodes;
+        const stringTable = new StringTableBuilder().build();
 
-        return FastTrieBlob.create(new FastTrieBlobInternals(nodes, info.info, info.characteristics));
+        const r = optimize
+            ? optimizeNodesWithStringTable({ nodes: sortedNodes, stringTable })
+            : { nodes: sortedNodes, stringTable };
+
+        return FastTrieBlob.create(new FastTrieBlobInternals(r.nodes, r.stringTable, info.info, info.characteristics));
     }
 
     toJSON(): {

packages/cspell-trie-lib/src/lib/TrieBlob/FastTrieBlobInternals.ts

@@ -1,20 +1,24 @@
 import type { PartialTrieInfo, TrieCharacteristics, TrieInfo } from '../ITrieNode/TrieInfo.ts';
+import type { StringTable } from '../StringTable/StringTable.ts';
 import { mergeOptionalWithDefaults } from '../utils/mergeOptionalWithDefaults.ts';
 import type { TrieBlobNode32 } from './TrieBlobFormat.ts';
 
 type Nodes = TrieBlobNode32[];
 
 export class FastTrieBlobInternals {
     readonly info: Readonly<TrieInfo>;
+    readonly stringTable: StringTable;
     readonly nodes: Nodes;
     readonly characteristics: Readonly<Partial<TrieCharacteristics>>;
 
     constructor(
         nodes: Nodes,
+        stringTable: StringTable,
         info: Readonly<PartialTrieInfo>,
         characteristics: Readonly<Partial<TrieCharacteristics>>,
     ) {
         this.nodes = nodes;
+        this.stringTable = stringTable;
 
         this.info = mergeOptionalWithDefaults(info);
         this.characteristics = characteristics;
@@ -39,8 +43,8 @@ export class FastTrieBlobInternalsAndMethods extends FastTrieBlobInternals imple
     readonly hasCompoundWords: boolean;
     readonly hasNonStrictWords: boolean;
 
-    constructor(nodes: Nodes, info: PartialTrieInfo, trieMethods: Readonly<TrieMethods>) {
-        super(nodes, info, trieMethods);
+    constructor(nodes: Nodes, stringTable: StringTable, info: PartialTrieInfo, trieMethods: Readonly<TrieMethods>) {
+        super(nodes, stringTable, info, trieMethods);
         this.nodeFindExact = trieMethods.nodeFindExact;
         this.nodeGetChild = trieMethods.nodeGetChild;
         this.isForbidden = trieMethods.isForbidden;