@silverbulletmd/silverbullet 2.5.3 → 2.6.1

package/plug-api/lib/async.ts

@@ -1,6 +1,9 @@
-export function throttle(func: () => void, limit: number): () => void {
+export function throttle(
+  func: () => void,
+  limit: number,
+): (() => void) & { flush(): void } {
   let timer: any = null;
-  return () => {
+  const throttled = () => {
     if (!timer) {
       timer = setTimeout(() => {
         func();
@@ -8,6 +11,15 @@ export function throttle(func: () => void, limit: number): () => void {
       }, limit);
     }
   };
+  // Immediately execute any pending call and cancel the timer
+  throttled.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+      func();
+    }
+  };
+  return throttled;
 }
 
 export function throttleImmediately(
@@ -38,7 +50,7 @@ export function timeout(ms: number): Promise<never> {
   return new Promise((_resolve, reject) =>
     setTimeout(() => {
       reject(new Error("timeout"));
-    }, ms)
+    }, ms),
   );
 }
 
@@ -58,7 +70,7 @@ export class PromiseQueue {
     return new Promise((resolve, reject) => {
       this.queue.push({ fn, resolve, reject });
       if (!this.processing) {
-        this.process();
+        void this.process();
       }
     });
   }
@@ -79,7 +91,7 @@ export class PromiseQueue {
       reject(error);
     }
 
-    this.process(); // Continue processing the next promise in the queue
+    void this.process(); // Continue processing the next promise in the queue
   }
 }
 
@@ -105,7 +117,8 @@ export async function batchRequests<I, O>(
   const batchResults = await Promise.all(batches.map(fn));
   // Flatten the results
   for (const batchResult of batchResults) {
-    if (Array.isArray(batchResult)) { // If fn returns an array, collect them
+    if (Array.isArray(batchResult)) {
+      // If fn returns an array, collect them
       results.push(...batchResult);
     }
   }

package/plug-api/lib/crypto.ts

@@ -42,9 +42,8 @@ export async function hashSHA256(
 ): Promise<string> {
   // Transform the string into an ArrayBuffer
   const encoder = new TextEncoder();
-  const data: Uint8Array = typeof message === "string"
-    ? encoder.encode(message)
-    : message;
+  const data: Uint8Array =
+    typeof message === "string" ? encoder.encode(message) : message;
 
   // Generate the hash
   const hashBuffer = await globalThis.crypto.subtle.digest(
@@ -53,9 +52,9 @@ export async function hashSHA256(
   );
 
   // Transform the hash into a hex string
-  return Array.from(new Uint8Array(hashBuffer)).map((b) =>
-    b.toString(16).padStart(2, "0")
-  ).join("");
+  return Array.from(new Uint8Array(hashBuffer))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
 }
 
 /**

package/plug-api/lib/dates.ts

@@ -3,11 +3,19 @@ export function niceDate(d: Date): string {
 }
 
 export function localDateString(d: Date): string {
-  return d.getFullYear() +
-    "-" + String(d.getMonth() + 1).padStart(2, "0") +
-    "-" + String(d.getDate()).padStart(2, "0") +
-    "T" + String(d.getHours()).padStart(2, "0") +
-    ":" + String(d.getMinutes()).padStart(2, "0") +
-    ":" + String(d.getSeconds()).padStart(2, "0") +
-    "." + String(d.getMilliseconds()).padStart(3, "0");
+  return (
+    d.getFullYear() +
+    "-" +
+    String(d.getMonth() + 1).padStart(2, "0") +
+    "-" +
+    String(d.getDate()).padStart(2, "0") +
+    "T" +
+    String(d.getHours()).padStart(2, "0") +
+    ":" +
+    String(d.getMinutes()).padStart(2, "0") +
+    ":" +
+    String(d.getSeconds()).padStart(2, "0") +
+    "." +
+    String(d.getMilliseconds()).padStart(3, "0")
+  );
 }

package/plug-api/lib/json.ts

@@ -52,11 +52,17 @@ export function deepEqual(a: any, b: any): boolean {
 export function cleanStringDate(d: Date): string {
   // If no significant time, return a date string only
   if (
-    d.getUTCHours() === 0 && d.getUTCMinutes() === 0 && d.getUTCSeconds() === 0
+    d.getUTCHours() === 0 &&
+    d.getUTCMinutes() === 0 &&
+    d.getUTCSeconds() === 0
   ) {
-    return d.getUTCFullYear() + "-" +
-      String(d.getUTCMonth() + 1).padStart(2, "0") + "-" +
-      String(d.getUTCDate()).padStart(2, "0");
+    return (
+      d.getUTCFullYear() +
+      "-" +
+      String(d.getUTCMonth() + 1).padStart(2, "0") +
+      "-" +
+      String(d.getUTCDate()).padStart(2, "0")
+    );
   } else {
     return d.toISOString();
   }

package/plug-api/lib/ref.ts

@@ -77,8 +77,9 @@ export function isValidName(name: string): boolean {
   // If the name, parses as a link and doesn't provide any other info we can be
   // sure it was only parsed as a path and that the path then conforms to all
   // the requirements
-  return !!ref && !ref.details && !ref.meta && name !== "" &&
-    encodeRef(ref) === name;
+  return (
+    !!ref && !ref.details && !ref.meta && name !== "" && encodeRef(ref) === name
+  );
 }
 
 /**
@@ -206,23 +207,22 @@ export function getOffsetFromHeader(
   parseTree: ParseTree,
   header: string,
 ): number {
-  const node = findNodeMatching(
-    parseTree,
-    (subTree) => {
-      if (!subTree.type || !subTree.type.startsWith("ATXHeading")) {
-        return false;
-      }
-
-      const mark = findNodeOfType(subTree, "HeaderMark");
-      if (!mark || mark.from === undefined || mark.to === undefined) {
-        return false;
-      }
-
-      return renderToText(subTree)
+  const node = findNodeMatching(parseTree, (subTree) => {
+    if (!subTree.type || !subTree.type.startsWith("ATXHeading")) {
+      return false;
+    }
+
+    const mark = findNodeOfType(subTree, "HeaderMark");
+    if (!mark || mark.from === undefined || mark.to === undefined) {
+      return false;
+    }
+
+    return (
+      renderToText(subTree)
         .slice(mark.to - mark.from)
-        .trimStart() === header.trim();
-    },
-  );
+        .trimStart() === header.trim()
+    );
+  });
 
   if (!node) {
     return -1;

package/plug-api/lib/resolve.ts

@@ -4,9 +4,11 @@ import type { Path } from "@silverbulletmd/silverbullet/lib/ref";
  * Determines wether a url points into the world wide web or to the local SB instance
  */
 export function isLocalURL(url: string): boolean {
-  return !url.includes("://") &&
+  return (
+    !url.includes("://") &&
     !url.startsWith("mailto:") &&
-    !url.startsWith("tel:");
+    !url.startsWith("tel:")
+  );
 }
 
 /**
@@ -22,10 +24,7 @@ export function fileName(name: string | Path): string | Path {
   return name.split("/").pop()!;
 }
 
-const builtinPrefixes = [
-  "tag:",
-  "search:",
-];
+const builtinPrefixes = ["tag:", "search:"];
 
 /**
  * Builtin pages are pages which SB should automatically consider as existing
@@ -51,11 +50,8 @@ export function resolveMarkdownLink(
   if (relative.startsWith("/")) {
     return relative.slice(1);
   } else {
-    const splitAbsolute = absolute
-      .split("/")
-      .slice(0, -1);
-    const splitRelative = relative
-      .split("/");
+    const splitAbsolute = absolute.split("/").slice(0, -1);
+    const splitRelative = relative.split("/");
 
     while (splitRelative && splitRelative[0] === "..") {
       splitAbsolute.pop();

package/plug-api/lib/tags.ts

@@ -1,15 +1,24 @@
+/** Check if a tag marks a page as a meta page (exact "meta" or "meta/..." subtag) */
+export function isMetaTag(tag: string): boolean {
+  return tag === "meta" || tag.startsWith("meta/");
+}
+
 /** Extract the name from hashtag text, removing # prefix and <angle brackets> if necessary */
 export function extractHashtag(text: string): string {
-  if (text[0] !== "#") { // you shouldn't call this function at all
+  if (text[0] !== "#") {
+    // you shouldn't call this function at all
     console.error("extractHashtag called on already clean string", text);
     return text;
   } else if (text[1] === "<") {
-    if (text.slice(-1) !== ">") { // this is malformed: #<name but maybe we're trying to autocomplete
+    if (text.slice(-1) !== ">") {
+      // this is malformed: #<name but maybe we're trying to autocomplete
       return text.slice(2);
-    } else { // this is correct #<name>
+    } else {
+      // this is correct #<name>
       return text.slice(2, -1);
     }
-  } else { // this is just #name
+  } else {
+    // this is just #name
     return text.slice(1);
   }
 }

package/plug-api/lib/transclusion.ts

@@ -1,7 +1,3 @@
-import {
-  isLocalURL,
-  resolveMarkdownLink,
-} from "@silverbulletmd/silverbullet/lib/resolve";
 import {
   mdLinkRegex,
   wikiLinkRegex,
@@ -34,9 +30,10 @@ export type ContentDimensions = {
  * Parse an alias, possibly containing dimensions into an object
  * @example "alias", "alias|100", "alias|100x200", "100", "100x200"
  */
-export function parseDimensionFromAlias(
-  text: string,
-): { alias: string; dimension?: ContentDimensions } {
+export function parseDimensionFromAlias(text: string): {
+  alias: string;
+  dimension?: ContentDimensions;
+} {
   let alias: string;
   let dim: ContentDimensions | undefined;
   if (text.includes("|")) {
@@ -71,10 +68,8 @@ export function parseDimensionFromAlias(
  * Parses a transclusion of the type `![[]]` or `![]()`
  * @param text
  */
-export function parseTransclusion(
-  text: string,
-): Transclusion | null {
-  let url, alias ;
+export function parseTransclusion(text: string): Transclusion | null {
+  let url, alias;
   let linktype: LinkType = "markdownlink";
   // TODO: Take in the tree and use tree nodes to get url and alias (Applies to all regex uses)
   mdLinkRegex.lastIndex = 0;
@@ -83,12 +78,6 @@ export function parseTransclusion(
   if ((match = mdLinkRegex.exec(text)) && match.groups) {
     ({ url, title: alias } = match.groups);
 
-    if (isLocalURL(url)) {
-      url = resolveMarkdownLink(
-        client.currentName(),
-        decodeURI(url),
-      );
-    }
     linktype = "markdownlink";
   } else if ((match = wikiLinkRegex.exec(text)) && match.groups) {
     ({ stringRef: url, alias } = match.groups);

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,88 @@ 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,
 ): void {
-  // Do a collect, but ignore the result
-  collectNodesMatching(tree, matchFn);
+  if (matchFn(tree)) {
+    return;
+  }
+  if (tree.children) {
+    for (const child of tree.children) {
+      traverseTree(child, matchFn);
+    }
+  }
 }
 
 export async function traverseTreeAsync(
   tree: ParseTree,
-  // Return value = should stop traversal?
+  // Return value = should stop traversal into children?
   matchFn: (tree: ParseTree) => Promise<boolean>,
 ): Promise<void> {
-  // Do a collect, but ignore the result
-  await collectNodesMatchingAsync(tree, matchFn);
+  if (await matchFn(tree)) {
+    return;
+  }
+  if (tree.children) {
+    for (const child of tree.children) {
+      await traverseTreeAsync(child, matchFn);
+    }
+  }
 }
 
 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 +313,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 +344,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);
 }