@delali/narsil 0.3.1-next.69 → 0.3.1-next.71

package/dist/{chunk-4VU5TWCR.mjs → chunk-LMO5TJUS.mjs}

@@ -1,5 +1,5 @@
-import { isTextFieldType, flattenSchema, SORTABLE_TEXT_FIELD_TYPE, isGeopointOrVectorType, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_PAGE_SIZE, PROTOTYPE_POLLUTION_KEYS, PREFIX_MAX_EXPANSIONS, MAX_CURSOR_ANCHOR_CODE_POINTS } from './chunk-6TGZG2TV.mjs';
-import { compareCodePoints, sortModeOf, defaultSortMode, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, isSortMode, SORT_MODES, SORT_VALUE_MAX_CODE_POINTS, compareSortValues } from './chunk-YMZCMH5M.mjs';
+import { isWordIndexedBase, flattenSchema, parsedTypeOf, isStringValuedBase, withSortableOption, isGeopointOrVectorType, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_PAGE_SIZE, PROTOTYPE_POLLUTION_KEYS, isWordIndexedFieldType, PREFIX_MAX_EXPANSIONS } from './chunk-653BNMAF.mjs';
+import { compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, isSortMode, SORT_MODES, compareSortValues } from './chunk-OI42GWLR.mjs';
 import { createNarsilError, ErrorCodes, NarsilError } from './chunk-USKFU7J5.mjs';
 
 // src/core/tokenizer/constants.ts
@@ -762,12 +762,12 @@ function stringArraysEqual(a, b) {
   }
   return true;
 }
-function textFieldsChanged(oldDoc, newDoc, flatSchema) {
-  for (const [path, fieldType] of Object.entries(flatSchema)) {
-    if (!isTextFieldType(fieldType) && fieldType !== "string[]") continue;
+function textFieldsChanged(oldDoc, newDoc, fields) {
+  for (const { path, base } of fields) {
+    if (!isWordIndexedBase(base)) continue;
     const oldVal = getNestedValue(oldDoc, path);
     const newVal = getNestedValue(newDoc, path);
-    if (fieldType !== "string[]") {
+    if (base === "string") {
       if (oldVal !== newVal) return true;
     } else {
       if (!stringArraysEqual(oldVal, newVal)) return true;
@@ -1192,6 +1192,16 @@ function requireFieldKind(fieldPath, operator, type, accepted) {
     operator
   );
 }
+function requireTextRangeField(fieldPath, operator, type) {
+  const parsed = parsedTypeOf(type);
+  if (parsed?.sortable && (parsed.base === "string" || parsed.base === "verbatim")) return;
+  const declared = type === void 0 ? `the schema has no field "${fieldPath}"` : `field "${fieldPath}" has type "${type}"`;
+  invalid(
+    `The engine applies "${operator}" with a text bound to a "string" or "verbatim" field whose type includes "sortable", but ${declared}`,
+    fieldPath,
+    operator
+  );
+}
 function requireRadius(fieldPath, radius) {
   const circle = radius;
   if (circle === null || typeof circle !== "object") {
@@ -1252,22 +1262,32 @@ function requireValidFilter(expression, fieldTypes, declaredOnly = false) {
 }
 function requireValidOperands(fieldPath, filter, type) {
   for (const operator of RANGE_OPERATORS) {
-    if (filter[operator] === void 0) continue;
-    if (!isFiniteNumber(filter[operator])) {
-      invalid(`"${operator}" on field "${fieldPath}" must be a finite number`, fieldPath, operator);
+    const bound = filter[operator];
+    if (bound === void 0) continue;
+    if (typeof bound === "string") {
+      requireTextRangeField(fieldPath, operator, type);
+      continue;
+    }
+    if (!isFiniteNumber(bound)) {
+      invalid(`"${operator}" on field "${fieldPath}" must be a finite number or a string`, fieldPath, operator);
     }
     requireFieldKind(fieldPath, operator, type, ["number"]);
   }
   if (filter.between !== void 0) {
     const bounds = filter.between;
-    if (!Array.isArray(bounds) || bounds.length !== 2 || !isFiniteNumber(bounds[0]) || !isFiniteNumber(bounds[1])) {
-      invalid(
-        `"between" on field "${fieldPath}" must be two finite numbers, the lower bound first`,
-        fieldPath,
-        "between"
-      );
+    const isPair = Array.isArray(bounds) && bounds.length === 2;
+    if (isPair && typeof bounds[0] === "string" && typeof bounds[1] === "string") {
+      requireTextRangeField(fieldPath, "between", type);
+    } else {
+      if (!isPair || !isFiniteNumber(bounds[0]) || !isFiniteNumber(bounds[1])) {
+        invalid(
+          `"between" on field "${fieldPath}" must be two finite numbers or two strings, the lower bound first`,
+          fieldPath,
+          "between"
+        );
+      }
+      requireFieldKind(fieldPath, "between", type, ["number"]);
     }
-    requireFieldKind(fieldPath, "between", type, ["number"]);
   }
   for (const operator of TEXT_OPERATORS) {
     if (filter[operator] === void 0) continue;
@@ -1365,10 +1385,11 @@ function requireSortableFields(sort, schema, strict = false) {
       );
     }
     requireSortMode(entry, fieldType);
-    if (fieldType === "string") {
+    const parsed = parsedTypeOf(fieldType);
+    if (parsed !== void 0 && isStringValuedBase(parsed.base) && !parsed.sortable) {
       throw new NarsilError(
         ErrorCodes.SEARCH_INVALID_FIELD,
-        `The engine sorts by text field "${entry.field}" only where the schema declares it "${SORTABLE_TEXT_FIELD_TYPE}", because ordering text takes far more memory per document than ordering a number`,
+        `The engine sorts by text field "${entry.field}" only where its type includes "sortable", as in "${withSortableOption(parsed)}", because it keeps up to the first ${SORT_VALUE_MAX_CODE_POINTS} code points of every document's value in memory to sort by a text field`,
         { field: entry.field, fieldType }
       );
     }
@@ -1406,22 +1427,6 @@ function invalidCursor(cursor, reason) {
   const shown = cursor.length > 100 ? `${cursor.slice(0, 100)}...` : cursor;
   return new NarsilError(ErrorCodes.SEARCH_INVALID_CURSOR, `Failed to decode cursor: ${reason}`, { cursor: shown });
 }
-function exceedsCodePoints(value, maximum) {
-  if (value.length <= maximum) return false;
-  let counted = 0;
-  let i = 0;
-  while (i < value.length) {
-    const unit = value.charCodeAt(i);
-    if (unit >= 55296 && unit < 56320 && i + 1 < value.length) {
-      const low = value.charCodeAt(i + 1);
-      if (low >= 56320 && low < 57344) i++;
-    }
-    i++;
-    counted++;
-    if (counted > maximum) return true;
-  }
-  return false;
-}
 function sortSignatureOf(sort) {
   const fields = normalizeSort(sort);
   if (fields.length === 0) return null;
@@ -1750,7 +1755,7 @@ function validateSearchFields(fields, flatSchema) {
     if (!fieldType) {
       throw new NarsilError(ErrorCodes.SEARCH_INVALID_FIELD, `Field "${field}" does not exist in the schema`, { field });
     }
-    if (!isTextFieldType(fieldType) && fieldType !== "string[]") {
+    if (!isWordIndexedFieldType(fieldType)) {
       throw new NarsilError(
         ErrorCodes.SEARCH_INVALID_FIELD,
         `Field "${field}" has type "${fieldType}" which cannot be used for full-text search`,