@silverbulletmd/silverbullet 2.5.3 → 2.7.0

package/plug-api/lib/tree.ts

@@ -1,5 +1,3 @@
-import { deepClone } from "@silverbulletmd/silverbullet/lib/json";
-
 export type ParseTree = {
   type?: string; // undefined === text node
   from?: number;
@@ -21,7 +19,7 @@ export function addParentPointers(tree: ParseTree) {
 }
 
 export function removeParentPointers(tree: ParseTree) {
-  delete tree.parent;
+  tree.parent = undefined;
   if (!tree.children) {
     return;
   }
@@ -51,38 +49,53 @@ export function collectNodesOfType(
   return collectNodesMatching(tree, (n) => n.type === nodeType);
 }
 
-export function collectNodesMatching(
+function collectNodesMatchingInternal(
   tree: ParseTree,
   matchFn: (tree: ParseTree) => boolean,
-): ParseTree[] {
+  results: ParseTree[],
+): void {
   if (matchFn(tree)) {
-    return [tree];
+    results.push(tree);
+    return;
   }
-  let results: ParseTree[] = [];
   if (tree.children) {
     for (const child of tree.children) {
-      results = [...results, ...collectNodesMatching(child, matchFn)];
+      collectNodesMatchingInternal(child, matchFn, results);
     }
   }
+}
+
+export function collectNodesMatching(
+  tree: ParseTree,
+  matchFn: (tree: ParseTree) => boolean,
+): ParseTree[] {
+  const results: ParseTree[] = [];
+  collectNodesMatchingInternal(tree, matchFn, results);
   return results;
 }
 
-export async function collectNodesMatchingAsync(
+async function collectNodesMatchingAsyncInternal(
   tree: ParseTree,
   matchFn: (tree: ParseTree) => Promise<boolean>,
-): Promise<ParseTree[]> {
+  results: ParseTree[],
+): Promise<void> {
   if (await matchFn(tree)) {
-    return [tree];
+    results.push(tree);
+    return;
   }
-  let results: ParseTree[] = [];
   if (tree.children) {
     for (const child of tree.children) {
-      results = [
-        ...results,
-        ...await collectNodesMatchingAsync(child, matchFn),
-      ];
+      await collectNodesMatchingAsyncInternal(child, matchFn, results);
     }
   }
+}
+
+export async function collectNodesMatchingAsync(
+  tree: ParseTree,
+  matchFn: (tree: ParseTree) => Promise<boolean>,
+): Promise<ParseTree[]> {
+  const results: ParseTree[] = [];
+  await collectNodesMatchingAsyncInternal(tree, matchFn, results);
   return results;
 }
 
@@ -92,19 +105,22 @@ export function replaceNodesMatching(
   substituteFn: (tree: ParseTree) => ParseTree | null | undefined,
 ) {
   if (tree?.children) {
-    const children = tree.children.slice();
-    for (const child of children) {
+    let i = 0;
+    while (i < tree.children.length) {
+      const child = tree.children[i];
       const subst = substituteFn(child);
       if (subst !== undefined) {
-        const pos = tree.children.indexOf(child);
         if (subst) {
-          tree.children.splice(pos, 1, subst);
+          tree.children[i] = subst;
+          i++;
         } else {
           // null = delete
-          tree.children.splice(pos, 1);
+          tree.children.splice(i, 1);
+          // don't increment i — next child shifted into this position
         }
       } else {
         replaceNodesMatching(child, substituteFn);
+        i++;
       }
     }
   }
@@ -115,19 +131,21 @@ export async function replaceNodesMatchingAsync(
   substituteFn: (tree: ParseTree) => Promise<ParseTree | null | undefined>,
 ) {
   if (tree.children) {
-    const children = tree.children.slice();
-    for (const child of children) {
+    let i = 0;
+    while (i < tree.children.length) {
+      const child = tree.children[i];
       const subst = await substituteFn(child);
       if (subst !== undefined) {
-        const pos = tree.children.indexOf(child);
         if (subst) {
-          tree.children.splice(pos, 1, subst);
+          tree.children[i] = subst;
+          i++;
         } else {
           // null = delete
-          tree.children.splice(pos, 1);
+          tree.children.splice(i, 1);
         }
       } else {
         await replaceNodesMatchingAsync(child, substituteFn);
+        i++;
       }
     }
   }
@@ -137,36 +155,119 @@ export function findNodeMatching(
   tree: ParseTree,
   matchFn: (tree: ParseTree) => boolean,
 ): ParseTree | null {
-  return collectNodesMatching(tree, matchFn)[0];
+  if (matchFn(tree)) {
+    return tree;
+  }
+  if (tree.children) {
+    for (const child of tree.children) {
+      const result = findNodeMatching(child, matchFn);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  return null;
 }
 
 export function findNodeOfType(
   tree: ParseTree,
   nodeType: string,
 ): ParseTree | null {
-  return collectNodesMatching(tree, (n) => n.type === nodeType)[0];
+  if (tree.type === nodeType) {
+    return tree;
+  }
+  if (tree.children) {
+    for (const child of tree.children) {
+      const result = findNodeOfType(child, nodeType);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  return null;
 }
 
 export function traverseTree(
   tree: ParseTree,
-  // Return value = should stop traversal?
+  // Return value = should stop traversal into children?
   matchFn: (tree: ParseTree) => boolean,
+  // Just log errors on exceptions, but don't stop traversal
+  catchVisitorErrors = false,
 ): void {
-  // Do a collect, but ignore the result
-  collectNodesMatching(tree, matchFn);
+  let stop = false;
+  if (catchVisitorErrors) {
+    try {
+      stop = matchFn(tree);
+    } catch (e: any) {
+      console.error(
+        `traverseTree visitor failed at node ${tree.type}@${tree.from}:`,
+        e?.stack ?? e,
+      );
+      return;
+    }
+  } else {
+    stop = matchFn(tree);
+  }
+  if (stop) {
+    return;
+  }
+  if (tree.children) {
+    for (const child of tree.children) {
+      traverseTree(child, matchFn, catchVisitorErrors);
+    }
+  }
 }
 
 export async function traverseTreeAsync(
   tree: ParseTree,
-  // Return value = should stop traversal?
+  // Return value = should stop traversal into children?
   matchFn: (tree: ParseTree) => Promise<boolean>,
+  catchVisitorErrors = false,
 ): Promise<void> {
-  // Do a collect, but ignore the result
-  await collectNodesMatchingAsync(tree, matchFn);
+  let stop = false;
+  if (catchVisitorErrors) {
+    try {
+      stop = await matchFn(tree);
+    } catch (e: any) {
+      console.error(
+        `traverseTreeAsync visitor failed at node ${tree.type}@${tree.from}:`,
+        e?.stack ?? e,
+      );
+      return;
+    }
+  } else {
+    stop = await matchFn(tree);
+  }
+  if (stop) {
+    return;
+  }
+  if (tree.children) {
+    for (const child of tree.children) {
+      await traverseTreeAsync(child, matchFn, catchVisitorErrors);
+    }
+  }
 }
 
 export function cloneTree(tree: ParseTree): ParseTree {
-  return deepClone(tree, ["parent"]);
+  if (tree.text !== undefined) {
+    return {
+      from: tree.from,
+      to: tree.to,
+      text: tree.text,
+    };
+  }
+  const clone: ParseTree = {
+    type: tree.type,
+    from: tree.from,
+    to: tree.to,
+  };
+  if (tree.children) {
+    clone.children = new Array(tree.children.length);
+    for (let i = 0; i < tree.children.length; i++) {
+      clone.children[i] = cloneTree(tree.children[i]);
+    }
+  }
+  return clone;
 }
 
 // Finds non-text node at position
@@ -243,21 +344,23 @@ export function renderToText(tree?: ParseTree): string {
   if (!tree) {
     return "";
   }
-  const pieces: string[] = [];
   if (tree.text !== undefined) {
     return tree.text;
   }
-  for (const child of tree.children!) {
-    pieces.push(renderToText(child));
+  const children = tree.children!;
+  if (children.length === 1) {
+    return renderToText(children[0]);
+  }
+  let result = "";
+  for (const child of children) {
+    result += renderToText(child);
   }
-  return pieces.join("");
+  return result;
 }
 
 export function cleanTree(tree: ParseTree, omitTrimmable = true): ParseTree {
   if (tree.type === "⚠") {
-    throw new Error(
-      `Parse error at pos ${tree.from}`,
-    );
+    throw new Error(`Parse error at pos ${tree.from}`);
   }
   if (tree.text !== undefined) {
     return tree;
@@ -272,7 +375,7 @@ export function cleanTree(tree: ParseTree, omitTrimmable = true): ParseTree {
     if (node.type && node.type !== "Comment") {
       ast.children!.push(cleanTree(node, omitTrimmable));
     }
-    if (node.text && (omitTrimmable && node.text.trim() || !omitTrimmable)) {
+    if (node.text && ((omitTrimmable && node.text.trim()) || !omitTrimmable)) {
       ast.children!.push(node);
     }
   }

package/plug-api/lib/yaml.ts

@@ -25,7 +25,9 @@ function serializeToYamlScalar(
     // Simple strings without special chars/meaning don't need quotes
     return value;
   } else if (
-    typeof value === "number" || typeof value === "boolean" || value === null
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    value === null
   ) {
     return String(value);
   }
@@ -46,10 +48,15 @@ function serializeToYamlValue(
     // Determine indentation for list items (base + 2 spaces)
     const itemIndentation = `${baseIndentation}  `;
     // Format each item recursively, preceded by '- ' marker
-    return "\n" +
-      value.map((item) =>
-        `${itemIndentation}- ${serializeToYamlValue(item, itemIndentation)}`
-      ).join("\n");
+    return (
+      "\n" +
+      value
+        .map(
+          (item) =>
+            `${itemIndentation}- ${serializeToYamlValue(item, itemIndentation)}`,
+        )
+        .join("\n")
+    );
     // Note: serializeToYamlValue is used recursively here to handle nested arrays/objects if needed in future
     // However, the current `applyMinimalSetKeyPatches` only handles top-level keys.
   } else if (typeof value === "object" && value !== null) {
@@ -58,22 +65,25 @@ function serializeToYamlValue(
     const itemIndentation = `${baseIndentation}  `;
     const entries = Object.entries(value);
     if (entries.length === 0) return "{}"; // Flow style empty objects
-    return "\n" +
-      entries.map(([key, val]) =>
-        `${itemIndentation}${key}: ${
-          serializeToYamlValue(val, itemIndentation)
-        }`
-      ).join("\n");
+    return (
+      "\n" +
+      entries
+        .map(
+          ([key, val]) =>
+            `${itemIndentation}${key}: ${serializeToYamlValue(
+              val,
+              itemIndentation,
+            )}`,
+        )
+        .join("\n")
+    );
   } else {
     // Handle scalars using the dedicated function
     return serializeToYamlScalar(value);
   }
 }
 
-export function applyPatches(
-  yamlString: string,
-  patches: YamlPatch[],
-): string {
+export function applyPatches(yamlString: string, patches: YamlPatch[]): string {
   let currentYaml = yamlString;
 
   for (const patch of patches) {

package/plug-api/syscalls/asset.ts

@@ -15,7 +15,7 @@ export async function readAsset(
   name: string,
   encoding: "utf8" | "dataurl" = "utf8",
 ): Promise<string> {
-  const dataUrl = await syscall("asset.readAsset", plugName, name) as string;
+  const dataUrl = (await syscall("asset.readAsset", plugName, name)) as string;
   switch (encoding) {
     case "utf8":
       return new TextDecoder().decode(base64DecodeDataUrl(dataUrl));

package/plug-api/syscalls/config.ts

@@ -31,10 +31,7 @@ export function set<T>(
 /**
  * Inserts a config value into an array
  */
-export function insert<T>(
-  path: string | string[],
-  value: T,
-): Promise<void> {
+export function insert<T>(path: string | string[], value: T): Promise<void> {
   return syscall("config.insert", path, value);
 }
 
@@ -56,3 +53,40 @@ export function has(path: string): Promise<boolean> {
 export function define(key: string, schema: any): Promise<void> {
   return syscall("config.define", key, schema);
 }
+
+/**
+ * Defines (or updates) a UI category for the configuration manager. Categories
+ * are referenced by name from a schema field's `ui.category` and are sorted in
+ * ascending `order` (default 0); unknown categories fall to the bottom in
+ * alphabetical order.
+ */
+export function defineCategory(
+  definition: { name: string; description?: string; order?: number },
+): Promise<void> {
+  return syscall("config.defineCategory", definition);
+}
+
+/**
+ * Gets all config values as a single object.
+ * @returns The entire config values object
+ */
+export function getValues(): Promise<Record<string, any>> {
+  return syscall("config.getValues");
+}
+
+/**
+ * Gets all defined config schemas.
+ * @returns The schema definitions object
+ */
+export function getSchemas(): Promise<Record<string, any>> {
+  return syscall("config.getSchemas");
+}
+
+/**
+ * Gets all registered UI categories for the configuration manager.
+ */
+export function getCategories(): Promise<
+  Record<string, { name: string; description?: string; order?: number }>
+> {
+  return syscall("config.getCategories");
+}

package/plug-api/syscalls/editor.ts

@@ -1,5 +1,9 @@
 import { syscall } from "../syscall.ts";
-import type { FilterOption, UploadFile } from "../../plug-api/types/client.ts";
+import type {
+  FilterOption,
+  NotificationType,
+  UploadFile,
+} from "../../plug-api/types/client.ts";
 import type { Path, Ref } from "../lib/ref.ts";
 import type { PageMeta } from "../../plug-api/types/index.ts";
 
@@ -77,9 +81,11 @@ export function getCursor(): Promise<number> {
 /**
  * Returns the line number and column number of the cursor in the editor
  */
-export function getSelection(): Promise<
-  { from: number; to: number; text: string }
-> {
+export function getSelection(): Promise<{
+  from: number;
+  to: number;
+  text: string;
+}> {
   return syscall("editor.getSelection");
 }
 
@@ -218,7 +224,7 @@ export function uploadFile(
  */
 export function flashNotification(
   message: string,
-  type: "info" | "error" = "info",
+  type: NotificationType = "info",
 ): Promise<void> {
   return syscall("editor.flashNotification", message, type);
 }
@@ -259,12 +265,17 @@ export function showPanel(
  * Hides a panel in the editor
  * @param id the location of the panel to hide
  */
-export function hidePanel(
-  id: "lhs" | "rhs" | "bhs" | "modal",
-): Promise<void> {
+export function hidePanel(id: "lhs" | "rhs" | "bhs" | "modal"): Promise<void> {
   return syscall("editor.hidePanel", id);
 }
 
+/**
+ * Returns focus to the main editor.
+ */
+export function focus(): Promise<void> {
+  return syscall("editor.focus");
+}
+
 export function showProgress(
   progressPercentage?: number,
   progressType?: string,
@@ -360,9 +371,7 @@ export function prompt(
  * @param message the message to show in the confirmation dialog
  * @returns
  */
-export function confirm(
-  message: string,
-): Promise<boolean> {
+export function confirm(message: string): Promise<boolean> {
   return syscall("editor.confirm", message);
 }
 
@@ -371,9 +380,7 @@ export function confirm(
  * @param message the message to show in the confirmation dialog
  * @returns
  */
-export function alert(
-  message: string,
-): Promise<boolean> {
+export function alert(message: string): Promise<boolean> {
   return syscall("editor.alert", message);
 }
 
@@ -466,6 +473,27 @@ export function deleteLine(): Promise<void> {
   return syscall("editor.deleteLine");
 }
 
+/**
+ * Select the entire document
+ */
+export function selectAll(): Promise<void> {
+  return syscall("editor.selectAll");
+}
+
+/**
+ * Increase indentation of the current line or selection
+ */
+export function indentMore(): Promise<void> {
+  return syscall("editor.indentMore");
+}
+
+/**
+ * Decrease indentation of the current line or selection
+ */
+export function indentLess(): Promise<void> {
+  return syscall("editor.indentLess");
+}
+
 /**
  * Comment or uncomment the current line in the editor
  */
@@ -481,6 +509,133 @@ export function moveLineDown(): Promise<void> {
   return syscall("editor.moveLineDown");
 }
 
+// Cursor motion syscalls (wrappers around @codemirror/commands functions)
+export function cursorCharLeft(): Promise<void> {
+  return syscall("editor.cursorCharLeft");
+}
+export function cursorCharRight(): Promise<void> {
+  return syscall("editor.cursorCharRight");
+}
+export function cursorGroupLeft(): Promise<void> {
+  return syscall("editor.cursorGroupLeft");
+}
+export function cursorGroupRight(): Promise<void> {
+  return syscall("editor.cursorGroupRight");
+}
+export function cursorLineBoundaryLeft(): Promise<void> {
+  return syscall("editor.cursorLineBoundaryLeft");
+}
+export function cursorLineBoundaryRight(): Promise<void> {
+  return syscall("editor.cursorLineBoundaryRight");
+}
+export function cursorLineStart(): Promise<void> {
+  return syscall("editor.cursorLineStart");
+}
+export function cursorLineEnd(): Promise<void> {
+  return syscall("editor.cursorLineEnd");
+}
+export function cursorDocStart(): Promise<void> {
+  return syscall("editor.cursorDocStart");
+}
+export function cursorDocEnd(): Promise<void> {
+  return syscall("editor.cursorDocEnd");
+}
+export function cursorLineUp(): Promise<void> {
+  return syscall("editor.cursorLineUp");
+}
+export function cursorLineDown(): Promise<void> {
+  return syscall("editor.cursorLineDown");
+}
+export function cursorPageUp(): Promise<void> {
+  return syscall("editor.cursorPageUp");
+}
+export function cursorPageDown(): Promise<void> {
+  return syscall("editor.cursorPageDown");
+}
+
+// Selection-extending motions
+export function selectCharLeft(): Promise<void> {
+  return syscall("editor.selectCharLeft");
+}
+export function selectCharRight(): Promise<void> {
+  return syscall("editor.selectCharRight");
+}
+export function selectGroupLeft(): Promise<void> {
+  return syscall("editor.selectGroupLeft");
+}
+export function selectGroupRight(): Promise<void> {
+  return syscall("editor.selectGroupRight");
+}
+export function selectLineBoundaryLeft(): Promise<void> {
+  return syscall("editor.selectLineBoundaryLeft");
+}
+export function selectLineBoundaryRight(): Promise<void> {
+  return syscall("editor.selectLineBoundaryRight");
+}
+export function selectLineStart(): Promise<void> {
+  return syscall("editor.selectLineStart");
+}
+export function selectLineEnd(): Promise<void> {
+  return syscall("editor.selectLineEnd");
+}
+export function selectDocStart(): Promise<void> {
+  return syscall("editor.selectDocStart");
+}
+export function selectDocEnd(): Promise<void> {
+  return syscall("editor.selectDocEnd");
+}
+export function selectLineUp(): Promise<void> {
+  return syscall("editor.selectLineUp");
+}
+export function selectLineDown(): Promise<void> {
+  return syscall("editor.selectLineDown");
+}
+export function selectPageUp(): Promise<void> {
+  return syscall("editor.selectPageUp");
+}
+export function selectPageDown(): Promise<void> {
+  return syscall("editor.selectPageDown");
+}
+
+// Delete
+export function deleteCharBackward(): Promise<void> {
+  return syscall("editor.deleteCharBackward");
+}
+export function deleteCharForward(): Promise<void> {
+  return syscall("editor.deleteCharForward");
+}
+export function deleteGroupBackward(): Promise<void> {
+  return syscall("editor.deleteGroupBackward");
+}
+export function deleteGroupForward(): Promise<void> {
+  return syscall("editor.deleteGroupForward");
+}
+export function deleteLineBoundaryBackward(): Promise<void> {
+  return syscall("editor.deleteLineBoundaryBackward");
+}
+export function deleteLineBoundaryForward(): Promise<void> {
+  return syscall("editor.deleteLineBoundaryForward");
+}
+export function transposeChars(): Promise<void> {
+  return syscall("editor.transposeChars");
+}
+
+// Enter: accepts completion if popup open, else inserts newline
+export function insertNewline(): Promise<void> {
+  return syscall("editor.insertNewline");
+}
+
+// Completion popup
+export function acceptCompletion(): Promise<boolean> {
+  return syscall("editor.acceptCompletion");
+}
+export function startCompletion(): Promise<void> {
+  return syscall("editor.startCompletion");
+}
+export function closeCompletion(): Promise<void> {
+  return syscall("editor.closeCompletion");
+}
+
 // Vim-mode specific syscalls
 
 /**

package/plug-api/syscalls/index.ts

@@ -75,3 +75,21 @@ export function deleteObject(
 ): Promise<void> {
   return syscall("index.deleteObject", page, tag, ref);
 }
+
+export type {
+  AnchorHit,
+  ResolveAnchorResult,
+} from "../../plugs/index/types.ts";
+import type { ResolveAnchorResult } from "../../plugs/index/types.ts";
+
+/**
+ * Resolves a `$name` anchor to its host. Returns `ok: true` with page +
+ * hostTag + range on success, or `ok: false` with `missing`/`duplicate`
+ * reason. When `page` is provided, the lookup is filtered to that page.
+ */
+export function resolveAnchor(
+  name: string,
+  page?: string,
+): Promise<ResolveAnchorResult> {
+  return syscall("index.resolveAnchor", name, page);
+}