@lde/search 0.24.1 → 0.24.3

package/dist/project.js

@@ -302,6 +302,17 @@ function referenceValues(node, alias, field, schema) {
  * `sortable`) stay on the declared `locales`, which drive the indexed, stemmed,
  * weighted fanout; a value in an undeclared language is not indexed. Absent
  * languages emit nothing.
+ *
+ * The two companions differ in what an absent language means. A search query
+ * fans out over *every* locale key at once, so a document titled in one
+ * language is found whichever language the reader asks in. A sort names a
+ * **single** key, so a locale key left empty is not “no value in Dutch” – it is
+ * the empty string, which ties with every other document missing that language
+ * and leaves them in relevance order. Each locale’s sort key therefore falls
+ * back to the document’s first value in `locales` order: a collection of
+ * untagged titles sorts by title in a Dutch request rather than not at all.
+ * Ordering across languages is approximate by nature; a total order over the
+ * titles a reader actually sees beats a partial one over the tagged few.
  */
 function applyText(document, values, field) {
     if (field.output) {
@@ -319,18 +330,22 @@ function applyText(document, values, field) {
     // here it simply indexes nothing.
     if (field.searchable !== undefined || field.sortable === true) {
         const names = physicalFields(field);
-        field.locales.forEach((locale, index) => {
-            const localeValues = values
-                .filter((value) => value.lang === locale)
-                .map((value) => value.value);
-            if (localeValues.length === 0) {
-                return;
-            }
-            if (field.searchable) {
+        const valuesPerLocale = field.locales.map((locale) => values
+            .filter((value) => value.lang === locale)
+            .map((value) => value.value));
+        // What every locale’s sort key falls back to: the document’s first value
+        // in `locales` order, which is the declaration’s own statement of which
+        // language stands in for the others.
+        const fallbackSortValue = valuesPerLocale.find((localeValues) => localeValues.length > 0)?.[0];
+        valuesPerLocale.forEach((localeValues, index) => {
+            if (field.searchable !== undefined && localeValues.length > 0) {
                 setString(document, names.search[index], foldedSearchValue(localeValues));
             }
-            if (field.sortable) {
-                setString(document, names.sort[index], fold(localeValues[0]));
+            if (field.sortable === true) {
+                const sortValue = localeValues[0] ?? fallbackSortValue;
+                if (sortValue !== undefined) {
+                    setString(document, names.sort[index], fold(sortValue));
+                }
             }
         });
     }

package/dist/schema.d.ts

@@ -208,7 +208,7 @@ export type ReferenceStrategy = {
     /**
      * Also project the target’s **own fields from this document’s frame**, so
      * the reference stores what the referring document states about the
-     * referent alongside the id – and the resolved document overlays it at
+     * referent alongside the id – and the resolved document replaces it at
      * query time rather than being the only source of it.
      *
      * What it buys is one field where there were two. A referent the graph

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "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",