@lde/search 0.27.0 → 0.27.1

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAkBL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAgBhB;AA4ID;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAc/B"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAkBL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAgBhB;AAwKD;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAc/B"}

package/dist/project.js

@@ -46,8 +46,8 @@ export function projectDocument(node, searchType, schema, context = NO_PROJECTIO
  * A Reference Type entry’s `id` is pruned here too. It is a reading device of
  * the same kind: the node IRI a derive on the referrer may read, and never a
  * document key – an entry is kept in no collection, a weld names the flat
- * identity companion beside it, and an entry's own key answers no query (ADR
- * 24). Left in, it would make an entry's shape depend on whether a publisher
+ * identity companion beside it, and an entry’s own key answers no query (ADR
+ * 24). Left in, it would make an entry’s shape depend on whether a publisher
  * minted an IRI for a relationship, and be a field the collection never
  * declared. A Root Type keeps its `id` wherever it nests: that is the key its
  * own collection files it under, and a `local` lookup resolves against it.
@@ -74,6 +74,11 @@ function pruneInternalFields(document, searchType, schema) {
         for (const referent of Array.isArray(nested) ? nested : [nested]) {
             pruneInternalFields(referent, nestedType, schema);
         }
+        // Two entries that differed only in their node IRI are one entry now that
+        // it is gone – two edge nodes stating the same fact.
+        if (nestedType.class === undefined && Array.isArray(nested)) {
+            document[field.name] = dedupeBy(nested, (referent) => JSON.stringify(referent));
+        }
     }
 }
 /** Apply every field of `searchType` to a fresh document, without pruning – the
@@ -82,13 +87,26 @@ function pruneInternalFields(document, searchType, schema) {
  *  once the whole nested structure is projected, so a derive at any depth can
  *  still read an internal field before it is removed. */
 function projectFields(node, searchType, schema, context, nested = false) {
-    const id = documentIdOf(node, searchType);
-    const document = id === undefined ? {} : { id };
+    const document = emptyDocument(documentIdOf(node, searchType), searchType);
     for (const field of searchType.fields) {
         applyField(document, node, field, searchType, schema, context, nested);
     }
     return document;
 }
+/** A document holding only its `id`, if it has one. A Reference Type entry’s
+ *  IRI is a reading device, so it is not enumerable there: a derive reads
+ *  `entry.id`, but `Object.keys`, a spread and `JSON.stringify` see only the
+ *  entry’s fields ({@link documentIdOf}). */
+function emptyDocument(id, searchType) {
+    if (id === undefined || searchType.class !== undefined) {
+        return id === undefined ? {} : { id };
+    }
+    return Object.defineProperty({}, 'id', {
+        value: id,
+        configurable: true,
+        writable: true,
+    });
+}
 /**
  * The document key a framed node carries, if any – an {@link isAbsoluteIri
  * absolute IRI}, the same rule {@link iriString} applies to a referent, so a
@@ -118,10 +136,14 @@ function documentKey(node) {
  * reading device only. A Reference Type is nested in its referrer and kept in
  * no collection, so nothing downstream resolves an entry by key, and
  * {@link pruneInternalFields} removes the `id` again before the document
- * leaves the projection, exactly as it removes a no-role helper field. What
- * stays is the window in between: a `derive` on the referrer reads the entry's
- * IRI where that IRI is the data – a IIIF manifest among a work's media, stated
- * by its `@id` and nothing else – and surfaces it under a field of its own.
+ * leaves the projection, exactly as it removes a no-role helper field. Until
+ * then it is not enumerable, so no step that walks an entry’s keys mistakes it
+ * for a field. What stays is the window in between: a `derive` on the referrer
+ * reads the entry’s IRI where that IRI is the data – a IIIF manifest among a
+ * work’s media, whose URL is its `@id` and stated nowhere else – and surfaces
+ * it under a field of its own. The entry still needs a field of its own (the
+ * manifest’s `encodingFormat`) to be a referent at all; an `@id` alone is not
+ * one.
  */
 function documentIdOf(node, searchType) {
     const nodeIri = documentKey(node);
@@ -485,10 +507,10 @@ function applyProjectionValue(document, field, from, context, schema) {
  * {@link ProjectedNode} for a single reference, an array for an `array` one.
  * A referent needs **no identity**: nesting carries its fields, not a document
  * key, so a blank-node referent – whose `@id` JSON-LD 1.1 framing prunes when its
- * label occurs once – nests exactly like a named one. Neither carries an `id`:
- * a Reference Type is kept in no collection, so nothing resolves an entry by
- * key, and an entry's shape no longer depends on whether a publisher minted an
- * IRI for the relationship ({@link documentIdOf}).
+ * label occurs once – nests exactly like a named one. Neither leaves the
+ * projection with an `id`: a Reference Type is kept in no collection, so
+ * nothing resolves an entry by key. A named referent carries its IRI as a
+ * non-enumerable `id` only while derives run ({@link documentIdOf}).
  * The referent is projected in full – internal fields included – so the
  * declaring type’s (or the reference type’s own) derives can read them;
  * {@link pruneInternalFields} then removes the internal fields from a *surfaced*
@@ -645,14 +667,12 @@ function applyNestedReferents(document, values, field, nestedType, schema, conte
     // or a keyed target re-keying two referent IRIs to the same document key. The
     // pre-fan-out shape deduped, because those values met inside one entry and
     // `applyFacet` deduped them there; split across entries they would reach the
-    // index and the API as byte-identical duplicates instead. A Reference Type
-    // entry's `id` is left out of the comparison: it is pruned before the
-    // document leaves the projection, so two statements of one fact through two
-    // edge nodes are the one entry they will be once it is gone. A Root Type's
-    // `id` is its key and stays part of what makes an entry distinct.
-    const distinct = dedupeBy(referents, (referent) => JSON.stringify(nestedType.class === undefined
-        ? { ...referent, id: undefined }
-        : referent));
+    // index and the API as byte-identical duplicates instead. The `id` is part
+    // of the key even where it is not enumerable: two named referents with the
+    // same fields are two IRIs a derive on the referrer may want, so they stay
+    // apart until {@link pruneInternalFields} drops a Reference Type entry’s `id`
+    // and dedupes what is left.
+    const distinct = dedupeBy(referents, (referent) => JSON.stringify([referent.id, referent]));
     if (distinct.length === 0) {
         return distinct;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "Engine- and domain-agnostic core for RDF-backed search: a unified declarative field model (SearchField/SearchType/SearchSchema), a neutral query IR, the SearchEngine port with logical result types, and a streaming CONSTRUCT-to-document projection. Bakes in no engine, protocol, or domain.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -52,7 +52,7 @@
   "devDependencies": {
     "@tpluscode/rdf-ns-builders": "^5.0.0",
     "@types/jsonld": "^1.5.15",
-    "n3": "^2.4.0"
+    "n3": "^2.7.12"
   },
   "peerDependencies": {
     "vitest": "^4.0.0"