@silverbulletmd/silverbullet 2.4.1

package/plug-api/lib/tree.ts

@@ -0,0 +1,232 @@
+import { deepClone } from "@silverbulletmd/silverbullet/lib/json";
+
+export type ParseTree = {
+  type?: string; // undefined === text node
+  from?: number;
+  to?: number;
+  text?: string;
+  children?: ParseTree[];
+  // Only present after running addParentPointers
+  parent?: ParseTree;
+};
+
+export function addParentPointers(tree: ParseTree) {
+  if (!tree.children) {
+    return;
+  }
+  for (const child of tree.children) {
+    child.parent = tree;
+    addParentPointers(child);
+  }
+}
+
+export function removeParentPointers(tree: ParseTree) {
+  delete tree.parent;
+  if (!tree.children) {
+    return;
+  }
+  for (const child of tree.children) {
+    removeParentPointers(child);
+  }
+}
+
+export function findParentMatching(
+  tree: ParseTree,
+  matchFn: (tree: ParseTree) => boolean,
+): ParseTree | null {
+  let node = tree.parent;
+  while (node) {
+    if (matchFn(node)) {
+      return node;
+    }
+    node = node.parent;
+  }
+  return null;
+}
+
+export function collectNodesOfType(
+  tree: ParseTree,
+  nodeType: string,
+): ParseTree[] {
+  return collectNodesMatching(tree, (n) => n.type === nodeType);
+}
+
+export function collectNodesMatching(
+  tree: ParseTree,
+  matchFn: (tree: ParseTree) => boolean,
+): ParseTree[] {
+  if (matchFn(tree)) {
+    return [tree];
+  }
+  let results: ParseTree[] = [];
+  if (tree.children) {
+    for (const child of tree.children) {
+      results = [...results, ...collectNodesMatching(child, matchFn)];
+    }
+  }
+  return results;
+}
+
+export async function collectNodesMatchingAsync(
+  tree: ParseTree,
+  matchFn: (tree: ParseTree) => Promise<boolean>,
+): Promise<ParseTree[]> {
+  if (await matchFn(tree)) {
+    return [tree];
+  }
+  let results: ParseTree[] = [];
+  if (tree.children) {
+    for (const child of tree.children) {
+      results = [
+        ...results,
+        ...await collectNodesMatchingAsync(child, matchFn),
+      ];
+    }
+  }
+  return results;
+}
+
+// return value: returning undefined = not matched, continue, null = delete, new node = replace
+export function replaceNodesMatching(
+  tree: ParseTree,
+  substituteFn: (tree: ParseTree) => ParseTree | null | undefined,
+) {
+  if (tree && tree.children) {
+    const children = tree.children.slice();
+    for (const child of children) {
+      const subst = substituteFn(child);
+      if (subst !== undefined) {
+        const pos = tree.children.indexOf(child);
+        if (subst) {
+          tree.children.splice(pos, 1, subst);
+        } else {
+          // null = delete
+          tree.children.splice(pos, 1);
+        }
+      } else {
+        replaceNodesMatching(child, substituteFn);
+      }
+    }
+  }
+}
+
+export async function replaceNodesMatchingAsync(
+  tree: ParseTree,
+  substituteFn: (tree: ParseTree) => Promise<ParseTree | null | undefined>,
+) {
+  if (tree.children) {
+    const children = tree.children.slice();
+    for (const child of children) {
+      const subst = await substituteFn(child);
+      if (subst !== undefined) {
+        const pos = tree.children.indexOf(child);
+        if (subst) {
+          tree.children.splice(pos, 1, subst);
+        } else {
+          // null = delete
+          tree.children.splice(pos, 1);
+        }
+      } else {
+        await replaceNodesMatchingAsync(child, substituteFn);
+      }
+    }
+  }
+}
+
+export function findNodeMatching(
+  tree: ParseTree,
+  matchFn: (tree: ParseTree) => boolean,
+): ParseTree | null {
+  return collectNodesMatching(tree, matchFn)[0];
+}
+
+export function findNodeOfType(
+  tree: ParseTree,
+  nodeType: string,
+): ParseTree | null {
+  return collectNodesMatching(tree, (n) => n.type === nodeType)[0];
+}
+
+export function traverseTree(
+  tree: ParseTree,
+  // Return value = should stop traversal?
+  matchFn: (tree: ParseTree) => boolean,
+): void {
+  // Do a collect, but ignore the result
+  collectNodesMatching(tree, matchFn);
+}
+
+export async function traverseTreeAsync(
+  tree: ParseTree,
+  // Return value = should stop traversal?
+  matchFn: (tree: ParseTree) => Promise<boolean>,
+): Promise<void> {
+  // Do a collect, but ignore the result
+  await collectNodesMatchingAsync(tree, matchFn);
+}
+
+export function cloneTree(tree: ParseTree): ParseTree {
+  return deepClone(tree, ["parent"]);
+}
+
+// Finds non-text node at position
+export function nodeAtPos(tree: ParseTree, pos: number): ParseTree | null {
+  if (pos < tree.from! || pos >= tree.to!) {
+    return null;
+  }
+  if (!tree.children) {
+    return tree;
+  }
+  for (const child of tree.children) {
+    const n = nodeAtPos(child, pos);
+    if (n && n.text !== undefined) {
+      // Got a text node, let's return its parent
+      return tree;
+    } else if (n) {
+      // Got it
+      return n;
+    }
+  }
+  return null;
+}
+
+// Turn ParseTree back into text
+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));
+  }
+  return pieces.join("");
+}
+
+export function cleanTree(tree: ParseTree, omitTrimmable = true): ParseTree {
+  if (tree.type === "⚠") {
+    throw new Error(
+      `Parse error at pos ${tree.from}`,
+    );
+  }
+  if (tree.text !== undefined) {
+    return tree;
+  }
+  const ast: ParseTree = {
+    type: tree.type,
+    children: [],
+    from: tree.from,
+    to: tree.to,
+  };
+  for (const node of tree.children!) {
+    if (node.type && node.type !== "Comment") {
+      ast.children!.push(cleanTree(node, omitTrimmable));
+    }
+    if (node.text && (omitTrimmable && node.text.trim() || !omitTrimmable)) {
+      ast.children!.push(node);
+    }
+  }
+  return ast;
+}

package/plug-api/lib/yaml.ts

@@ -0,0 +1,284 @@
+// Define the patch structure
+export interface YamlPatch {
+  op: "set-key" | "delete-key";
+  path: string; // Still assuming simple, top-level key names
+  value?: any; // Required for set-key, not used for delete-key
+}
+
+// Helper function specifically for serializing scalar types
+function serializeToYamlScalar(
+  value: string | number | boolean | null,
+): string {
+  if (typeof value === "string") {
+    // Always quote empty strings and strings with special characters
+    if (
+      value === "" || // Empty string
+      value.match(/[:{#}[],&*!|>'"%@`]/) || // Special YAML characters (added % and ")
+      /^\d+(\.\d+)?([eE][+-]?\d+)?$/.test(value) || // Looks like a number
+      value.includes(":") || // Contains colons
+      ["true", "false", "null", "yes", "no", "on", "off"].includes(
+        value.toLowerCase(),
+      )
+    ) {
+      return JSON.stringify(value);
+    }
+    // Simple strings without special chars/meaning don't need quotes
+    return value;
+  } else if (
+    typeof value === "number" || typeof value === "boolean" || value === null
+  ) {
+    return String(value);
+  }
+  // Default for unsupported scalar types (e.g., undefined)
+  return "null";
+}
+
+// Updated helper function to serialize various JS types to YAML string representations
+// Added baseIndentation parameter for handling nested lists correctly (though we only use it for top-level lists here)
+function serializeToYamlValue(
+  value: any,
+  baseIndentation: string = "",
+): string {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]"; // Use flow style for empty arrays for simplicity
+    }
+    // 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");
+    // 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) {
+    // Basic object serialization (not requested, but good to consider)
+    // This is highly simplified and doesn't handle nesting well without more context
+    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");
+  } else {
+    // Handle scalars using the dedicated function
+    return serializeToYamlScalar(value);
+  }
+}
+
+export function applyPatches(
+  yamlString: string,
+  patches: YamlPatch[],
+): string {
+  let currentYaml = yamlString;
+
+  for (const patch of patches) {
+    if (patch.op === "delete-key") {
+      // Handle delete operation
+      const key = patch.path;
+      const lines = currentYaml.split("\n");
+      let keyLineIndex = -1;
+      let startDeleteIndex = -1;
+      let endDeleteIndex = -1;
+
+      // Find the key line
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith(key + ":")) {
+          keyLineIndex = i;
+          startDeleteIndex = i;
+          endDeleteIndex = i;
+
+          // Look backwards for preceding comments (delete them too)
+          for (let j = i - 1; j >= 0; j--) {
+            const prevLine = lines[j].trim();
+            if (prevLine.startsWith("#")) {
+              startDeleteIndex = j;
+            } else if (prevLine !== "") {
+              break;
+            } else {
+              // Empty line - include it in deletion if followed by comments
+              if (startDeleteIndex < i) {
+                startDeleteIndex = j;
+              } else {
+                break;
+              }
+            }
+          }
+
+          // Determine the indentation of the key
+          const keyIndent = lines[i].match(/^(\s*)/)?.[1] || "";
+
+          // Look forwards to find all content belonging to this key
+          // This includes list items and nested objects
+          for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j];
+            const trimmedNextLine = nextLine.trim();
+
+            // Empty line - continue looking
+            if (trimmedNextLine === "") {
+              continue;
+            }
+
+            // Comment at same or greater indentation - might be trailing comment
+            if (trimmedNextLine.startsWith("#")) {
+              const commentIndent = nextLine.match(/^(\s*)/)?.[1] || "";
+              if (commentIndent.length > keyIndent.length) {
+                endDeleteIndex = j;
+                continue;
+              } else {
+                // Comment at same or less indentation - not part of this key
+                break;
+              }
+            }
+
+            // Check indentation of next non-empty, non-comment line
+            const nextIndent = nextLine.match(/^(\s*)/)?.[1] || "";
+            if (nextIndent.length > keyIndent.length) {
+              // This line is indented more than the key, so it belongs to the key
+              endDeleteIndex = j;
+            } else {
+              // This line is at same or less indentation, so it's a new key
+              break;
+            }
+          }
+
+          break;
+        }
+      }
+
+      if (keyLineIndex !== -1) {
+        // Delete the lines from startDeleteIndex to endDeleteIndex (inclusive)
+        const beforeDelete = lines.slice(0, startDeleteIndex);
+        const afterDelete = lines.slice(endDeleteIndex + 1);
+
+        // Clean up excessive empty lines at the boundary
+        // Remove trailing empty lines from beforeDelete
+        while (
+          beforeDelete.length > 0 &&
+          beforeDelete[beforeDelete.length - 1].trim() === ""
+        ) {
+          beforeDelete.pop();
+        }
+
+        // Remove leading empty lines from afterDelete (but keep one if there's content after)
+        let leadingEmptyCount = 0;
+        for (const line of afterDelete) {
+          if (line.trim() === "") {
+            leadingEmptyCount++;
+          } else {
+            break;
+          }
+        }
+        const cleanedAfterDelete = afterDelete.slice(
+          Math.min(leadingEmptyCount, 1),
+        );
+
+        currentYaml = [...beforeDelete, ...cleanedAfterDelete].join("\n");
+        if (currentYaml && !currentYaml.endsWith("\n")) {
+          currentYaml += "\n";
+        }
+      }
+      // If key not found, do nothing
+      continue;
+    }
+
+    if (patch.op !== "set-key") continue;
+
+    const key = patch.path;
+
+    // Split the YAML into lines for easier processing
+    const lines = currentYaml.split("\n");
+    let keyLineIndex = -1;
+    let commentBlock = "";
+    let trailingComments = "";
+    let inlineComment = "";
+
+    // Find the key line and collect comments
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith(key + ":")) {
+        keyLineIndex = i;
+        // Extract inline comment if present
+        const commentMatch = line.match(/#.*$/);
+        if (commentMatch) {
+          inlineComment = commentMatch[0];
+        }
+        // Look backwards for comments
+        for (let j = i - 1; j >= 0; j--) {
+          const prevLine = lines[j].trim();
+          if (prevLine.startsWith("#")) {
+            commentBlock = lines[j] + "\n" + commentBlock;
+          } else if (prevLine !== "") {
+            break;
+          }
+        }
+        // Look forwards for comments
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+          if (nextLine.startsWith("#")) {
+            trailingComments += lines[j] + "\n";
+          } else if (nextLine !== "") {
+            break;
+          }
+        }
+        break;
+      }
+    }
+
+    // Serialize the new value
+    const serializedNewValue = serializeToYamlValue(patch.value);
+
+    // Create the replacement line
+    let replacementLine: string;
+    if (serializedNewValue.startsWith("\n")) {
+      // For lists/objects, the key line ends with just ':'
+      replacementLine = `${key}:${inlineComment}${serializedNewValue}`;
+    } else {
+      // For scalars, format as key: value
+      replacementLine = `${key}: ${serializedNewValue}${
+        inlineComment ? " " + inlineComment : ""
+      }`;
+    }
+
+    if (keyLineIndex !== -1) {
+      // Replace the existing line while preserving comments
+      const beforeKey = lines.slice(
+        0,
+        keyLineIndex - commentBlock.split("\n").filter(Boolean).length,
+      );
+      const afterKey = lines.slice(
+        keyLineIndex + 1 + trailingComments.split("\n").filter(Boolean).length,
+      );
+
+      // Build the new content
+      const newContent = [
+        ...beforeKey,
+        ...commentBlock.split("\n").filter(Boolean),
+        replacementLine,
+        ...trailingComments.split("\n").filter(Boolean),
+        ...afterKey,
+      ];
+
+      // Join lines and ensure proper newlines
+      currentYaml = newContent.join("\n").replace(/\n*$/, "\n") + "\n";
+    } else {
+      // Key not found: Add the new key-value pair to the end
+      const newLineBlock = replacementLine;
+      if (currentYaml.trim() === "") {
+        currentYaml = newLineBlock + "\n";
+      } else {
+        currentYaml = currentYaml.replace(/\n*$/, "\n") + newLineBlock + "\n";
+      }
+    }
+  }
+
+  // Ensure the result ends with a newline
+  return currentYaml.replace(/\n*$/, "\n");
+}

package/plug-api/syscall.ts

@@ -0,0 +1,15 @@
+// declare global {
+//   function syscall(name: string, ...args: any[]): Promise<any>;
+// }
+
+// This is the case when running tests only, so giving it a dummy syscall function
+if (typeof (globalThis as any).syscall === "undefined") {
+  (globalThis as any).syscall = () => {
+    throw new Error("Not implemented here");
+  };
+}
+
+// Late binding syscall
+export function syscall(name: string, ...args: any[]): Promise<any> {
+  return (globalThis as any).syscall(name, ...args);
+}

package/plug-api/syscalls/asset.ts

@@ -0,0 +1,36 @@
+import { base64DecodeDataUrl } from "../lib/crypto.ts";
+import { syscall } from "../syscall.ts";
+
+import type { FileMeta } from "../../plug-api/types/index.ts";
+
+/**
+ * Reads an asset embedded in a plug (via the `assets` field in the plug manifest).
+ * @param plugName name of the plug to read asset from
+ * @param name name of the asset to read
+ * @param encoding either "utf8" or "dataurl"
+ * @returns the content of the asset in the requested encoding
+ */
+export async function readAsset(
+  plugName: string,
+  name: string,
+  encoding: "utf8" | "dataurl" = "utf8",
+): Promise<string> {
+  const dataUrl = await syscall("asset.readAsset", plugName, name) as string;
+  switch (encoding) {
+    case "utf8":
+      return new TextDecoder().decode(base64DecodeDataUrl(dataUrl));
+    case "dataurl":
+      return dataUrl;
+  }
+}
+
+export async function listFiles(plugName: string): Promise<FileMeta[]> {
+  return await syscall("asset.listFiles", plugName);
+}
+
+export async function getFileMeta(
+  plugName: string,
+  name: string,
+): Promise<FileMeta> {
+  return await syscall("asset.getFileMeta", plugName, name);
+}

package/plug-api/syscalls/client_store.ts

@@ -0,0 +1,33 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * Implements a very simple (string) key value store for the client.
+ * Generally should only be used to set some client-specific states, such as preferences.
+ * @module
+ */
+
+/**
+ * Sets a value in the client store.
+ * @param key the key to set
+ * @param value the value to set
+ */
+export function set(key: string, value: any): Promise<void> {
+  return syscall("clientStore.set", key, value);
+}
+
+/**
+ * Gets a value from the client store.
+ * @param key the key to get
+ * @returns the value associated with the key
+ */
+export function get(key: string): Promise<any> {
+  return syscall("clientStore.get", key);
+}
+
+/**
+ * Deletes a value from the client store.
+ * @param key the key to delete
+ */
+export function del(key: string): Promise<void> {
+  return syscall("clientStore.delete", key);
+}

package/plug-api/syscalls/code_widget.ts

@@ -0,0 +1,8 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * Refreshes all code widgets on the page that support it.
+ */
+export function refreshAll(): Promise<void> {
+  return syscall("codeWidget.refreshAll");
+}

package/plug-api/syscalls/config.ts

@@ -0,0 +1,58 @@
+import { syscall } from "../syscall.ts";
+
+/**
+ * Gets a config value by path, with support for dot notation.
+ * @param path The path to get the value from
+ * @param defaultValue The default value to return if the path doesn't exist
+ * @returns The value at the path, or the default value
+ */
+export function get<T>(path: string | string[], defaultValue: T): Promise<T> {
+  return syscall("config.get", path, defaultValue);
+}
+
+/**
+ * Sets a config value by path, with support for dot notation.
+ * @param path The path to set the value at
+ * @param value The value to set
+ */
+export function set<T>(path: string, value: T): Promise<void>;
+/**
+ * Sets multiple config values at once.
+ * @param values An object containing key-value pairs to set
+ */
+export function set(values: Record<string, any>): Promise<void>;
+export function set<T>(
+  pathOrValues: string | Record<string, any>,
+  value?: T,
+): Promise<void> {
+  return syscall("config.set", pathOrValues, value);
+}
+
+/**
+ * Inserts a config value into an array
+ */
+export function insert<T>(
+  path: string | string[],
+  value: T,
+): Promise<void> {
+  return syscall("config.insert", path, value);
+}
+
+/**
+ * Checks if a config path exists.
+ * @param path The path to check
+ * @returns True if the path exists, false otherwise
+ */
+export function has(path: string): Promise<boolean> {
+  return syscall("config.has", path);
+}
+
+/**
+ * Defines a JSON schema for a configuration key.
+ * The schema will be used to validate values when setting this key.
+ * @param key The configuration key to define a schema for
+ * @param schema The JSON schema to validate against
+ */
+export function define(key: string, schema: any): Promise<void> {
+  return syscall("config.define", key, schema);
+}