@bilig/core 0.1.33 → 0.1.35

package/dist/engine/services/lookup-service.d.ts

@@ -29,6 +29,36 @@ export type ExactVectorMatchResult = {
     position: number | undefined;
 };
 export type ApproximateVectorMatchResult = ExactVectorMatchResult;
+export interface PreparedExactVectorLookup {
+    sheetName: string;
+    rowStart: number;
+    rowEnd: number;
+    col: number;
+    columnVersion: number;
+    comparableKind: "numeric" | "text" | "mixed";
+    uniformStart: number | undefined;
+    uniformStep: number | undefined;
+    firstPositions: Map<string, number>;
+    lastPositions: Map<string, number>;
+    firstNumericPositions: Map<number, number> | undefined;
+    lastNumericPositions: Map<number, number> | undefined;
+    firstTextPositions: Map<string, number> | undefined;
+    lastTextPositions: Map<string, number> | undefined;
+}
+export interface PreparedApproximateVectorLookup {
+    sheetName: string;
+    rowStart: number;
+    rowEnd: number;
+    col: number;
+    columnVersion: number;
+    comparableKind: "numeric" | "text" | undefined;
+    uniformStart: number | undefined;
+    uniformStep: number | undefined;
+    sortedAscending: boolean;
+    sortedDescending: boolean;
+    numericValues: Float64Array | undefined;
+    textValues: string[] | undefined;
+}
 export interface EngineLookupService {
     readonly findExactVectorMatch: (request: ExactVectorMatchRequest) => ExactVectorMatchResult;
     readonly findApproximateVectorMatch: (request: ApproximateVectorMatchRequest) => ApproximateVectorMatchResult;
@@ -44,6 +74,28 @@ export interface EngineLookupService {
         rowEnd: number;
         col: number;
     }) => void;
+    readonly prepareExactVectorLookup: (request: {
+        sheetName: string;
+        rowStart: number;
+        rowEnd: number;
+        col: number;
+    }) => PreparedExactVectorLookup;
+    readonly findPreparedExactVectorMatch: (request: {
+        lookupValue: CellValue;
+        prepared: PreparedExactVectorLookup;
+        searchMode: 1 | -1;
+    }) => ExactVectorMatchResult;
+    readonly prepareApproximateVectorLookup: (request: {
+        sheetName: string;
+        rowStart: number;
+        rowEnd: number;
+        col: number;
+    }) => PreparedApproximateVectorLookup;
+    readonly findPreparedApproximateVectorMatch: (request: {
+        lookupValue: CellValue;
+        prepared: PreparedApproximateVectorLookup;
+        matchMode: 1 | -1;
+    }) => ApproximateVectorMatchResult;
 }
 export declare function createEngineLookupService(args: {
     readonly state: Pick<EngineRuntimeState, "workbook" | "strings">;

package/dist/engine/services/lookup-service.js

@@ -34,6 +34,11 @@ function normalizeApproximateComparableValue(value, lookupString, stringId = 0)
             return { kind: "invalid" };
     }
 }
+function normalizeLookupText(value, lookupString) {
+    return (value.stringId !== undefined && value.stringId !== 0
+        ? lookupString(value.stringId)
+        : value.value).toUpperCase();
+}
 function compareApproximateNumeric(left, right) {
     if (left === right) {
         return 0;
@@ -46,6 +51,22 @@ function compareApproximateText(left, right) {
     }
     return left < right ? -1 : 1;
 }
+function detectUniformNumericStep(values) {
+    if (values.length < 2) {
+        return undefined;
+    }
+    const start = values[0];
+    const step = values[1] - start;
+    if (!Number.isFinite(step) || step === 0) {
+        return undefined;
+    }
+    for (let index = 2; index < values.length; index += 1) {
+        if (values[index] - values[index - 1] !== step) {
+            return undefined;
+        }
+    }
+    return { start, step };
+}
 export function createEngineLookupService(args) {
     const exactColumnIndices = new Map();
     const approximateColumnIndices = new Map();
@@ -88,6 +109,14 @@ export function createEngineLookupService(args) {
     const buildExactColumnIndex = (sheetName, col, rowStart, rowEnd) => {
         const firstPositions = new Map();
         const lastPositions = new Map();
+        const firstNumericPositions = new Map();
+        const lastNumericPositions = new Map();
+        const firstTextPositions = new Map();
+        const lastTextPositions = new Map();
+        const numericSequence = [];
+        let sawNumeric = false;
+        let sawText = false;
+        let sawOther = false;
         for (let row = rowStart; row <= rowEnd; row += 1) {
             const key = readNormalizedKeyAt(sheetName, row, col);
             if (key === undefined) {
@@ -97,11 +126,48 @@ export function createEngineLookupService(args) {
                 firstPositions.set(key, row);
             }
             lastPositions.set(key, row);
+            if (key.startsWith("n:")) {
+                const numericValue = Number(key.slice(2));
+                if (!firstNumericPositions.has(numericValue)) {
+                    firstNumericPositions.set(numericValue, row);
+                }
+                lastNumericPositions.set(numericValue, row);
+                numericSequence.push(numericValue);
+                sawNumeric = true;
+                continue;
+            }
+            if (key.startsWith("s:")) {
+                const textValue = key.slice(2);
+                if (!firstTextPositions.has(textValue)) {
+                    firstTextPositions.set(textValue, row);
+                }
+                lastTextPositions.set(textValue, row);
+                sawText = true;
+                continue;
+            }
+            sawOther = true;
         }
+        const comparableKind = sawOther || (sawNumeric && sawText)
+            ? "mixed"
+            : sawNumeric
+                ? "numeric"
+                : sawText
+                    ? "text"
+                    : "mixed";
+        const uniformNumericStep = comparableKind === "numeric"
+            ? detectUniformNumericStep(Float64Array.from(numericSequence))
+            : undefined;
         return {
             columnVersion: args.state.workbook.getSheetColumnVersion(sheetName, col),
+            comparableKind,
+            uniformStart: uniformNumericStep?.start,
+            uniformStep: uniformNumericStep?.step,
             firstPositions,
             lastPositions,
+            firstNumericPositions: comparableKind === "numeric" ? firstNumericPositions : undefined,
+            lastNumericPositions: comparableKind === "numeric" ? lastNumericPositions : undefined,
+            firstTextPositions: comparableKind === "text" ? firstTextPositions : undefined,
+            lastTextPositions: comparableKind === "text" ? lastTextPositions : undefined,
         };
     };
     const buildApproximateColumnIndex = (sheetName, col, rowStart, rowEnd) => {
@@ -161,8 +227,12 @@ export function createEngineLookupService(args) {
             return {
                 columnVersion: args.state.workbook.getSheetColumnVersion(sheetName, col),
                 comparableKind: undefined,
+                uniformStart: undefined,
+                uniformStep: undefined,
                 sortedAscending: false,
                 sortedDescending: false,
+                numericValues: undefined,
+                textValues: undefined,
             };
         }
         if (hasText) {
@@ -181,8 +251,11 @@ export function createEngineLookupService(args) {
             return {
                 columnVersion: args.state.workbook.getSheetColumnVersion(sheetName, col),
                 comparableKind: "text",
+                uniformStart: undefined,
+                uniformStep: undefined,
                 sortedAscending,
                 sortedDescending,
+                numericValues: undefined,
                 textValues,
             };
         }
@@ -198,12 +271,16 @@ export function createEngineLookupService(args) {
                 sortedDescending = false;
             }
         }
+        const uniformNumericStep = detectUniformNumericStep(numericValues);
         return {
             columnVersion: args.state.workbook.getSheetColumnVersion(sheetName, col),
             comparableKind: "numeric",
+            uniformStart: uniformNumericStep?.start,
+            uniformStep: uniformNumericStep?.step,
             sortedAscending,
             sortedDescending,
             numericValues,
+            textValues: undefined,
         };
     };
     const resolveExactColumnBounds = (request) => {
@@ -250,6 +327,76 @@ export function createEngineLookupService(args) {
         }
         return entry;
     };
+    const prepareExactVectorLookup = (request) => {
+        const entry = ensureExactColumnIndex(request.sheetName, request.col, request.rowStart, request.rowEnd);
+        return {
+            sheetName: request.sheetName,
+            rowStart: request.rowStart,
+            rowEnd: request.rowEnd,
+            col: request.col,
+            columnVersion: entry.columnVersion,
+            comparableKind: entry.comparableKind,
+            uniformStart: entry.uniformStart,
+            uniformStep: entry.uniformStep,
+            firstPositions: entry.firstPositions,
+            lastPositions: entry.lastPositions,
+            firstNumericPositions: entry.firstNumericPositions,
+            lastNumericPositions: entry.lastNumericPositions,
+            firstTextPositions: entry.firstTextPositions,
+            lastTextPositions: entry.lastTextPositions,
+        };
+    };
+    const prepareApproximateVectorLookup = (request) => {
+        const entry = ensureApproximateColumnIndex(request.sheetName, request.col, request.rowStart, request.rowEnd);
+        return {
+            sheetName: request.sheetName,
+            rowStart: request.rowStart,
+            rowEnd: request.rowEnd,
+            col: request.col,
+            columnVersion: entry.columnVersion,
+            comparableKind: entry.comparableKind,
+            uniformStart: entry.uniformStart,
+            uniformStep: entry.uniformStep,
+            sortedAscending: entry.sortedAscending,
+            sortedDescending: entry.sortedDescending,
+            numericValues: entry.numericValues,
+            textValues: entry.textValues,
+        };
+    };
+    const refreshPreparedExactVectorLookup = (prepared) => {
+        const columnVersion = args.state.workbook.getSheetColumnVersion(prepared.sheetName, prepared.col);
+        if (columnVersion === prepared.columnVersion) {
+            return prepared;
+        }
+        const refreshed = prepareExactVectorLookup(prepared);
+        prepared.columnVersion = refreshed.columnVersion;
+        prepared.comparableKind = refreshed.comparableKind;
+        prepared.uniformStart = refreshed.uniformStart;
+        prepared.uniformStep = refreshed.uniformStep;
+        prepared.firstPositions = refreshed.firstPositions;
+        prepared.lastPositions = refreshed.lastPositions;
+        prepared.firstNumericPositions = refreshed.firstNumericPositions;
+        prepared.lastNumericPositions = refreshed.lastNumericPositions;
+        prepared.firstTextPositions = refreshed.firstTextPositions;
+        prepared.lastTextPositions = refreshed.lastTextPositions;
+        return prepared;
+    };
+    const refreshPreparedApproximateVectorLookup = (prepared) => {
+        const columnVersion = args.state.workbook.getSheetColumnVersion(prepared.sheetName, prepared.col);
+        if (columnVersion === prepared.columnVersion) {
+            return prepared;
+        }
+        const refreshed = prepareApproximateVectorLookup(prepared);
+        prepared.columnVersion = refreshed.columnVersion;
+        prepared.comparableKind = refreshed.comparableKind;
+        prepared.uniformStart = refreshed.uniformStart;
+        prepared.uniformStep = refreshed.uniformStep;
+        prepared.sortedAscending = refreshed.sortedAscending;
+        prepared.sortedDescending = refreshed.sortedDescending;
+        prepared.numericValues = refreshed.numericValues;
+        prepared.textValues = refreshed.textValues;
+        return prepared;
+    };
     return {
         primeExactColumnIndex(request) {
             ensureExactColumnIndex(request.sheetName, request.col, request.rowStart, request.rowEnd);
@@ -257,6 +404,202 @@ export function createEngineLookupService(args) {
         primeApproximateColumnIndex(request) {
             ensureApproximateColumnIndex(request.sheetName, request.col, request.rowStart, request.rowEnd);
         },
+        prepareExactVectorLookup(request) {
+            return prepareExactVectorLookup(request);
+        },
+        findPreparedExactVectorMatch(request) {
+            const prepared = refreshPreparedExactVectorLookup(request.prepared);
+            if (prepared.comparableKind === "numeric") {
+                if (request.lookupValue.tag === ValueTag.Error) {
+                    return { handled: false };
+                }
+                if (request.lookupValue.tag !== ValueTag.Number) {
+                    return { handled: true, position: undefined };
+                }
+                const numericValue = Object.is(request.lookupValue.value, -0)
+                    ? 0
+                    : request.lookupValue.value;
+                if (prepared.uniformStart !== undefined && prepared.uniformStep !== undefined) {
+                    const relative = (numericValue - prepared.uniformStart) / prepared.uniformStep;
+                    const position = Number.isInteger(relative) ? relative + 1 : undefined;
+                    return {
+                        handled: true,
+                        position: position !== undefined &&
+                            position >= 1 &&
+                            position <= prepared.rowEnd - prepared.rowStart + 1
+                            ? position
+                            : undefined,
+                    };
+                }
+                const numericMap = request.searchMode === -1
+                    ? prepared.lastNumericPositions
+                    : prepared.firstNumericPositions;
+                const row = numericMap?.get(numericValue);
+                return {
+                    handled: true,
+                    position: row === undefined ? undefined : row - prepared.rowStart + 1,
+                };
+            }
+            if (prepared.comparableKind === "text") {
+                if (request.lookupValue.tag === ValueTag.Error) {
+                    return { handled: false };
+                }
+                if (request.lookupValue.tag !== ValueTag.String) {
+                    return { handled: true, position: undefined };
+                }
+                const textValue = normalizeLookupText(request.lookupValue, (id) => args.state.strings.get(id));
+                const textMap = request.searchMode === -1 ? prepared.lastTextPositions : prepared.firstTextPositions;
+                const row = textMap?.get(textValue);
+                return {
+                    handled: true,
+                    position: row === undefined ? undefined : row - prepared.rowStart + 1,
+                };
+            }
+            const normalizedLookupKey = normalizeExactLookupKey(request.lookupValue, (id) => args.state.strings.get(id));
+            if (normalizedLookupKey === undefined) {
+                return { handled: false };
+            }
+            const row = request.searchMode === -1
+                ? prepared.lastPositions.get(normalizedLookupKey)
+                : prepared.firstPositions.get(normalizedLookupKey);
+            return {
+                handled: true,
+                position: row === undefined ? undefined : row - prepared.rowStart + 1,
+            };
+        },
+        prepareApproximateVectorLookup(request) {
+            return prepareApproximateVectorLookup(request);
+        },
+        findPreparedApproximateVectorMatch(request) {
+            const prepared = refreshPreparedApproximateVectorLookup(request.prepared);
+            if (prepared.comparableKind === undefined) {
+                return { handled: false };
+            }
+            if (request.matchMode === 1 && !prepared.sortedAscending) {
+                return { handled: false };
+            }
+            if (request.matchMode === -1 && !prepared.sortedDescending) {
+                return { handled: false };
+            }
+            if (prepared.comparableKind === "numeric") {
+                let lookupValue;
+                switch (request.lookupValue.tag) {
+                    case ValueTag.Empty:
+                        lookupValue = 0;
+                        break;
+                    case ValueTag.Number:
+                        lookupValue = Object.is(request.lookupValue.value, -0) ? 0 : request.lookupValue.value;
+                        break;
+                    case ValueTag.Boolean:
+                        lookupValue = request.lookupValue.value ? 1 : 0;
+                        break;
+                    case ValueTag.Error:
+                        return { handled: false };
+                    case ValueTag.String:
+                        return { handled: false };
+                }
+                const values = prepared.numericValues;
+                if (!values) {
+                    return { handled: false };
+                }
+                if (prepared.uniformStart !== undefined && prepared.uniformStep !== undefined) {
+                    const { uniformStart, uniformStep } = prepared;
+                    const lastValue = uniformStart + uniformStep * (values.length - 1);
+                    if (request.matchMode === 1 && uniformStep > 0) {
+                        if (lookupValue < uniformStart) {
+                            return { handled: true, position: undefined };
+                        }
+                        if (lookupValue >= lastValue) {
+                            return { handled: true, position: values.length };
+                        }
+                        const position = Math.floor((lookupValue - uniformStart) / uniformStep) + 1;
+                        return { handled: true, position: Math.min(values.length, Math.max(1, position)) };
+                    }
+                    if (request.matchMode === -1 && uniformStep < 0) {
+                        if (lookupValue > uniformStart) {
+                            return { handled: true, position: undefined };
+                        }
+                        if (lookupValue <= lastValue) {
+                            return { handled: true, position: values.length };
+                        }
+                        const position = Math.floor((uniformStart - lookupValue) / -uniformStep) + 1;
+                        return { handled: true, position: Math.min(values.length, Math.max(1, position)) };
+                    }
+                }
+                let low = 0;
+                let high = values.length - 1;
+                let best = -1;
+                while (low <= high) {
+                    const mid = (low + high) >> 1;
+                    const comparison = compareApproximateNumeric(values[mid], lookupValue);
+                    if (request.matchMode === 1) {
+                        if (comparison <= 0) {
+                            best = mid;
+                            low = mid + 1;
+                        }
+                        else {
+                            high = mid - 1;
+                        }
+                    }
+                    else if (comparison >= 0) {
+                        best = mid;
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid - 1;
+                    }
+                }
+                return {
+                    handled: true,
+                    position: best === -1 ? undefined : best + 1,
+                };
+            }
+            let lookupValue;
+            switch (request.lookupValue.tag) {
+                case ValueTag.Empty:
+                    lookupValue = "";
+                    break;
+                case ValueTag.String:
+                    lookupValue = normalizeLookupText(request.lookupValue, (id) => args.state.strings.get(id));
+                    break;
+                case ValueTag.Error:
+                    return { handled: false };
+                case ValueTag.Number:
+                case ValueTag.Boolean:
+                    return { handled: false };
+            }
+            const values = prepared.textValues;
+            if (!values) {
+                return { handled: false };
+            }
+            let low = 0;
+            let high = values.length - 1;
+            let best = -1;
+            while (low <= high) {
+                const mid = (low + high) >> 1;
+                const comparison = compareApproximateText(values[mid], lookupValue);
+                if (request.matchMode === 1) {
+                    if (comparison <= 0) {
+                        best = mid;
+                        low = mid + 1;
+                    }
+                    else {
+                        high = mid - 1;
+                    }
+                }
+                else if (comparison >= 0) {
+                    best = mid;
+                    low = mid + 1;
+                }
+                else {
+                    high = mid - 1;
+                }
+            }
+            return {
+                handled: true,
+                position: best === -1 ? undefined : best + 1,
+            };
+        },
         findExactVectorMatch(request) {
             const normalizedLookupKey = normalizeExactLookupKey(request.lookupValue, (id) => args.state.strings.get(id));
             if (normalizedLookupKey === undefined) {
@@ -267,6 +610,50 @@ export function createEngineLookupService(args) {
                 return { handled: false };
             }
             const entry = ensureExactColumnIndex(request.sheetName, bounds.col, bounds.rowStart, bounds.rowEnd);
+            if (entry.comparableKind === "numeric") {
+                if (request.lookupValue.tag === ValueTag.Error) {
+                    return { handled: false };
+                }
+                if (request.lookupValue.tag !== ValueTag.Number) {
+                    return { handled: true, position: undefined };
+                }
+                const numericValue = Object.is(request.lookupValue.value, -0)
+                    ? 0
+                    : request.lookupValue.value;
+                if (entry.uniformStart !== undefined && entry.uniformStep !== undefined) {
+                    const relative = (numericValue - entry.uniformStart) / entry.uniformStep;
+                    const position = Number.isInteger(relative) ? relative + 1 : undefined;
+                    return {
+                        handled: true,
+                        position: position !== undefined &&
+                            position >= 1 &&
+                            position <= bounds.rowEnd - bounds.rowStart + 1
+                            ? position
+                            : undefined,
+                    };
+                }
+                const numericMap = request.searchMode === -1 ? entry.lastNumericPositions : entry.firstNumericPositions;
+                const row = numericMap?.get(numericValue);
+                return {
+                    handled: true,
+                    position: row === undefined ? undefined : row - bounds.rowStart + 1,
+                };
+            }
+            if (entry.comparableKind === "text") {
+                if (request.lookupValue.tag === ValueTag.Error) {
+                    return { handled: false };
+                }
+                if (request.lookupValue.tag !== ValueTag.String) {
+                    return { handled: true, position: undefined };
+                }
+                const textValue = normalizeLookupText(request.lookupValue, (id) => args.state.strings.get(id));
+                const textMap = request.searchMode === -1 ? entry.lastTextPositions : entry.firstTextPositions;
+                const row = textMap?.get(textValue);
+                return {
+                    handled: true,
+                    position: row === undefined ? undefined : row - bounds.rowStart + 1,
+                };
+            }
             const row = request.searchMode === -1
                 ? entry.lastPositions.get(normalizedLookupKey)
                 : entry.firstPositions.get(normalizedLookupKey);
@@ -291,15 +678,50 @@ export function createEngineLookupService(args) {
                 return { handled: false };
             }
             if (entry.comparableKind === "numeric") {
-                const lookup = normalizeApproximateComparableValue(request.lookupValue, (id) => args.state.strings.get(id));
-                if (lookup.kind !== "numeric" && lookup.kind !== "empty") {
-                    return { handled: false };
+                let lookupValue;
+                switch (request.lookupValue.tag) {
+                    case ValueTag.Empty:
+                        lookupValue = 0;
+                        break;
+                    case ValueTag.Number:
+                        lookupValue = Object.is(request.lookupValue.value, -0) ? 0 : request.lookupValue.value;
+                        break;
+                    case ValueTag.Boolean:
+                        lookupValue = request.lookupValue.value ? 1 : 0;
+                        break;
+                    case ValueTag.Error:
+                        return { handled: false };
+                    case ValueTag.String:
+                        return { handled: false };
                 }
                 const values = entry.numericValues;
                 if (!values) {
                     return { handled: false };
                 }
-                const lookupValue = lookup.kind === "numeric" ? lookup.value : 0;
+                if (entry.uniformStart !== undefined && entry.uniformStep !== undefined) {
+                    const { uniformStart, uniformStep } = entry;
+                    const lastValue = uniformStart + uniformStep * (values.length - 1);
+                    if (request.matchMode === 1 && uniformStep > 0) {
+                        if (lookupValue < uniformStart) {
+                            return { handled: true, position: undefined };
+                        }
+                        if (lookupValue >= lastValue) {
+                            return { handled: true, position: values.length };
+                        }
+                        const position = Math.floor((lookupValue - uniformStart) / uniformStep) + 1;
+                        return { handled: true, position: Math.min(values.length, Math.max(1, position)) };
+                    }
+                    if (request.matchMode === -1 && uniformStep < 0) {
+                        if (lookupValue > uniformStart) {
+                            return { handled: true, position: undefined };
+                        }
+                        if (lookupValue <= lastValue) {
+                            return { handled: true, position: values.length };
+                        }
+                        const position = Math.floor((uniformStart - lookupValue) / -uniformStep) + 1;
+                        return { handled: true, position: Math.min(values.length, Math.max(1, position)) };
+                    }
+                }
                 let low = 0;
                 let high = values.length - 1;
                 let best = -1;