@lde/search-typesense 0.29.1 → 0.29.3

package/dist/search.js

@@ -694,31 +694,33 @@ function nestedValue(raw, field, referenceType, labels, schema, children) {
 }
 /**
  * Rebuild a {@link ReferenceStrategy.local local} lookup: the endpoint’s own
- * document as this document stated it, with the **resolved** document overlaid
+ * document as this document stated it, **replaced** by the resolved document
  * where the lookup found one.
  *
- * Both sides are the target type’s flat physical shape, so the merge is a plain
- * override and the authoritative value wins field by field. Three cases fall
- * out of one expression, which is the point of storing local fields
- * unconditionally:
+ * Replaced rather than merged, because both sides are the target type’s flat
+ * physical shape and a logical field fans out into several physical ones: a
+ * name this document stated in one language would survive beside the target’s
+ * name in another, and a field the target’s record does not carry would
+ * survive after the target dropped it. The resolved document carries what the
+ * projection asked for, and a resolved entry says exactly that – what a plain
+ * lookup says too. Three cases fall out of one expression, which is the point
+ * of storing local fields unconditionally:
  *
- * - identified and indexed → the target’s own record, over what was stated here;
+ * - identified and indexed → the target’s own record;
  * - identified but not indexed → what was stated here, plus the `id`, rather
  *   than a bare IRI;
  * - not identified → what was stated here, with no `id` at all.
  */
 function localLookupValue(raw, field, target, resolved, labels, schema) {
     const fetched = resolved?.via === 'lookup' ? resolved.documents : new Map();
-    const merged = (Array.isArray(raw) ? raw : [raw])
+    const entries = (Array.isArray(raw) ? raw : [raw])
         .filter((entry) => typeof entry === 'object' && entry !== null)
         .map((entry) => {
         const id = typeof entry.id === 'string' ? entry.id : undefined;
         const authoritative = id === undefined ? undefined : fetched.get(id);
-        return authoritative === undefined
-            ? entry
-            : { ...entry, ...authoritative };
+        return authoritative ?? entry;
     });
-    return nestedValue(merged, field, target, labels, schema, resolved?.children);
+    return nestedValue(entries, field, target, labels, schema, resolved?.children);
 }
 /**
  * Rebuild a resolved `lookup` reference: each stored IRI becomes the referent’s

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.29.1",
+  "version": "0.29.3",
   "description": "Typesense implementation of the @lde/search SearchEngine port: collection-schema builder, query compiler, label-resolving result reconstruction, and blue/green index lifecycle. Engine-specific (Typesense) but domain-agnostic.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -25,7 +25,7 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/search": "^0.24.1",
+    "@lde/search": "^0.24.3",
     "@lde/text-normalization": "^0.1.2",
     "tslib": "^2.3.0",
     "typesense": "^3.0.6"