@silverbulletmd/silverbullet 2.4.2 → 2.6.1

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
+  );
 }
 
 /**
@@ -87,7 +88,7 @@ export function isValidName(name: string): boolean {
 export function isValidPath(path: string): path is Path {
   const ref = parseToRef(path);
 
-  return !!ref && ref.path === path;
+  return !!ref && ref.path === path && path !== "";
 }
 
 /**
@@ -95,7 +96,7 @@ export function isValidPath(path: string): path is Path {
  * TO THE INNER WORKINGS OF SILVERBULLET AND CHANGES COULD INTRODUCE MAJOR BUGS
  */
 const refRegex =
-  /^(?<meta>\^)?(?<path>(?!.*\.[a-zA-Z0-9]+\.md$)(?!\/?(\.|\^))(?!.*(?:\/|^)\.{1,2}(?:\/|$)|.*\/{2})(?!.*(?:\]\]|\[\[))[^@#\|<>]*)(@(?<pos>\d+)|@[Ll](?<line>\d+)(?:[Cc](?<col>\d+))?|#\s*(?<header>.*))?$/;
+  /^(?<meta>\^)?(?<path>(?!.*\.[a-zA-Z0-9]+\.md$)(?!\/?(\.|\^))(?!.*(?:\/|^)\.{1,2}(?:\/|$)|.*\/{2})(?!.*(?:\]\]|\[\[))[^@#|<>]*)(@(?<pos>\d+)|@[Ll](?<line>\d+)(?:[Cc](?<col>\d+))?|#\s*(?<header>.*))?$/;
 
 /**
  * Parses a reference string into a ref object.
@@ -118,13 +119,13 @@ export function parseToRef(stringRef: string): Ref | null {
   if (groups.pos !== undefined) {
     ref.details = {
       type: "position",
-      pos: parseInt(groups.pos),
+      pos: parseInt(groups.pos, 10),
     };
   } else if (groups.line !== undefined) {
     ref.details = {
       type: "linecolumn",
-      line: parseInt(groups.line),
-      column: groups.col !== undefined ? parseInt(groups.col) : 1,
+      line: parseInt(groups.line, 10),
+      column: groups.col !== undefined ? parseInt(groups.col, 10) : 1,
     };
   } else if (groups.header !== undefined) {
     ref.details = {
@@ -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("|")) {
@@ -45,19 +42,19 @@ export function parseDimensionFromAlias(
     const [width, height] = dimPart.split("x");
     dim = {};
     if (width) {
-      dim.width = parseInt(width);
+      dim.width = parseInt(width, 10);
     }
     if (height) {
-      dim.height = parseInt(height);
+      dim.height = parseInt(height, 10);
     }
   } else if (/^[x\d]/.test(text)) {
     const [width, height] = text.split("x");
     dim = {};
     if (width) {
-      dim.width = parseInt(width);
+      dim.width = parseInt(width, 10);
     }
     if (height) {
-      dim.height = parseInt(height);
+      dim.height = parseInt(height, 10);
     }
     alias = "";
   } else {
@@ -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 = undefined;
+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;
 }
 
@@ -91,20 +104,23 @@ 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) {
+  if (tree?.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
@@ -182,7 +252,8 @@ export function nodeAtPos(tree: ParseTree, pos: number): ParseTree | null {
     if (n && n.text !== undefined) {
       // Got a text node, let's return its parent
       return tree;
-    } else if (n) {
+    }
+    if (n) {
       // Got it
       return n;
     }
@@ -190,26 +261,75 @@ export function nodeAtPos(tree: ParseTree, pos: number): ParseTree | null {
   return null;
 }
 
+// Ensure a TableRow/TableHeader has a TableCell between every pair of
+// TableDelimiters, and optionally pad to match columnCount.
+// headerHasLeadingDelim indicates whether the header starts with a delimiter.
+export function normalizeTableRow(
+  row: ParseTree,
+  columnCount?: number,
+  headerHasLeadingDelim?: boolean,
+): void {
+  const children = row.children;
+  if (!children) return;
+  const normalized: ParseTree[] = [];
+  let lookingForCell = false;
+  for (const child of children) {
+    if (child.type === "TableDelimiter" && lookingForCell) {
+      normalized.push({ type: "TableCell", children: [] });
+    }
+    if (child.type === "TableDelimiter") {
+      lookingForCell = true;
+    }
+    if (child.type === "TableCell") {
+      lookingForCell = false;
+    }
+    normalized.push(child);
+  }
+  row.children = normalized;
+
+  // Fix leading-pipe mismatch: row has leading delimiter but header doesn't
+  if (headerHasLeadingDelim === false) {
+    if (row.children.length > 0 && row.children[0].type === "TableDelimiter") {
+      // Insert empty cell after the leading delimiter
+      row.children.splice(1, 0, { type: "TableCell", children: [] });
+    }
+  }
+
+  // Pad trailing empty cells to match header column count
+  if (columnCount !== undefined) {
+    let cellCount = 0;
+    for (const child of row.children) {
+      if (child.type === "TableCell") cellCount++;
+    }
+    while (cellCount < columnCount) {
+      row.children.push({ type: "TableCell", children: [] });
+      cellCount++;
+    }
+  }
+}
+
 // 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));
+  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;
@@ -224,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);
     }
   }