@riboseinc/anafero-cli 0.0.66 → 0.0.68

package/bootstrap.js

@@ -69144,6 +69144,11 @@ schema (${ast._tag}): ${ast}`;
         version: Literal4("0.1"),
         /** The entry point, path to XML of a Metanorma document or collection. */
         entryPoint: String$2.pipe(nonEmptyString3()),
+        /**
+         * Workspace title.
+         * If not provided, “document ID • document title” is used.
+         */
+        workspaceTitle: String$2.pipe(nonEmptyString3()).pipe(optional2),
         /**
          * Which reader modules to use.
          *
@@ -72101,7 +72106,88 @@ schema (${ast._tag}): ${ast}`;
           throw new Error("Requested key does not exist");
         }
       },
-      dump: () => cache
+      dump: async (stream2, signal) => {
+        async function* buildKeypaths(obj, currentPath, seen, paths2, signal2) {
+          if (signal2.aborted) {
+            throw new Error("Aborted");
+          }
+          for (const key of Object.keys(Object(obj))) {
+            const val = obj[key];
+            if (typeof val === "string" || Object.keys(Object(val)).length === 0) {
+              yield [...currentPath, key];
+            } else {
+              const complexVal = val;
+              if (!seen.has(complexVal)) {
+                seen.add(complexVal);
+                yield* buildKeypaths(
+                  complexVal,
+                  [...currentPath, key],
+                  seen,
+                  paths2,
+                  signal2
+                );
+              }
+            }
+          }
+        }
+        async function write(data, end) {
+          return new Promise((resolve) => {
+            if (end) {
+              stream2.end(data, function() {
+                resolve();
+              });
+            } else {
+              stream2.write(data, function() {
+                resolve();
+              });
+            }
+          });
+        }
+        function serializeKeypath(idx2, keyPaths) {
+          const keyPath = keyPaths[idx2];
+          if (keyPath) {
+            const keyString = keyPath.join(".");
+            keyPath.reverse();
+            let valueCursor = cache;
+            while (true) {
+              let part = keyPath.pop();
+              if (part) {
+                valueCursor = valueCursor[part];
+              } else {
+                break;
+              }
+            }
+            return `
+${JSON.stringify(keyString)}: ${valueCursor}`;
+          } else {
+            return null;
+          }
+        }
+        const pathGen = buildKeypaths(cache, [], /* @__PURE__ */ new Set(), [], signal);
+        const paths = [];
+        for await (const p of pathGen) {
+          paths.push(p);
+        }
+        await write(`
+-- starting dumping ${paths.length} paths --`);
+        let idx = 0;
+        const chunkSize = 1e3;
+        let chunk3 = "";
+        while (true) {
+          if (idx > 0 && idx % chunkSize === 0) {
+            await write(chunk3);
+            chunk3 = "";
+          }
+          const nextItem = serializeKeypath(idx, paths);
+          if (nextItem) {
+            chunk3 = chunk3 + nextItem;
+          } else {
+            break;
+          }
+          idx += 1;
+        }
+        return;
+      }
     };
   }
   var init_cache = __esm({
@@ -72214,12 +72300,48 @@ schema (${ast._tag}): ${ast}`;
 
   // ../anafero/search.mts
   function preprocessStringForIndexing(text) {
-    return text.normalize("NFKD").replace(/\p{Diacritic}/gu, "").trim();
+    return text.normalize("NFKD").replace(/\p{Diacritic}/gu, "").replace(/[\p{P}$+<=>^`|~]/gu, " ").replace(/[\u200B-\u200D\uFEFF]/g, "").trim();
   }
-  function extractRelationsForIndexing(uri, graph, isDefinedSubject) {
-    return graph.filter(
-      ([s, p, o2]) => p === "hasPart" && (s === uri || s === ROOT_SUBJECT) && !o2.startsWith("data:") && (!isURIString(o2) || !isDefinedSubject(o2))
+  function extractRelationsForIndexing(uri, graph, isIndexable, isAlreadyIndexed, _seen, _log) {
+    const seen = _seen ?? /* @__PURE__ */ new Set();
+    seen.add(uri);
+    const nonData = graph.filter(
+      ([, , o2]) => !o2.startsWith("data:")
+    );
+    const immediateGraph = nonData.filter(
+      ([s, ,]) => s === uri || s === ROOT_SUBJECT
+    );
+    const references = immediateGraph.filter(
+      ([, , o2]) => isURIString(o2)
     );
+    const indexable = immediateGraph.filter(
+      ([s, p, o2]) => !isURIString(o2) && isIndexable([s, p, o2])
+    ).map(([, , o2]) => o2).filter((o2) => o2.trim() !== "");
+    for (const [, , o2] of references) {
+      if (_log) {
+        console.debug(
+          "search: processing triple object",
+          { o: o2, isAlreadyIndexed: isAlreadyIndexed(o2) }
+        );
+      }
+      if (!isAlreadyIndexed(o2) && !seen.has(o2)) {
+        indexable.push(...extractRelationsForIndexing(
+          o2,
+          graph,
+          isIndexable,
+          isAlreadyIndexed,
+          seen,
+          _log
+        ));
+      }
+    }
+    if (_log) {
+      console.debug(
+        "search: obtained indexable from graph",
+        { uri, graph, indexable }
+      );
+    }
+    return indexable;
   }
   var init_search = __esm({
     "../anafero/search.mts"() {
@@ -109636,7 +109758,7 @@ schema (${ast._tag}): ${ast}`;
       const debouncedQueryTrimmed = debouncedQuery.trim();
       if (index && debouncedQueryTrimmed !== "") {
         const normalizedQuery = preprocessStringForIndexing(
-          debouncedQuery.replace(/:/g, " ").replace(/\*/g, " ")
+          debouncedQuery.replace(/\*/g, " ")
         );
         const tokens = import_lunr.default.tokenizer(normalizedQuery);
         console.debug("Search: tokens", tokens);