@silverbulletmd/silverbullet 2.4.1

package/plug-api/lib/limited_map.ts

@@ -0,0 +1,72 @@
+type LimitedMapRecord<V> = {
+  value: V;
+  la: number;
+  expTimer?: number;
+};
+
+export class LimitedMap<V> {
+  private map: Map<string, LimitedMapRecord<V>>;
+
+  constructor(
+    private maxSize: number,
+    initialJson: Record<string, LimitedMapRecord<V>> = {},
+  ) {
+    this.map = new Map(Object.entries(initialJson));
+  }
+
+  /**
+   * @param key
+   * @param value
+   * @param ttl time to live (in ms)
+   */
+  set(key: string, value: V, ttl?: number) {
+    const entry: LimitedMapRecord<V> = { value, la: Date.now() };
+    if (ttl) {
+      const existingEntry = this.map.get(key);
+      if (existingEntry?.expTimer) {
+        clearTimeout(existingEntry.expTimer);
+      }
+      entry.expTimer = setTimeout(() => {
+        this.map.delete(key);
+      }, ttl);
+    }
+    if (this.map.size >= this.maxSize) {
+      // Remove the oldest key before adding a new one
+      const oldestKey = this.getOldestKey();
+      this.map.delete(oldestKey!);
+    }
+    this.map.set(key, entry);
+  }
+
+  get(key: string): V | undefined {
+    const entry = this.map.get(key);
+    if (entry) {
+      // Update the last accessed timestamp
+      entry.la = Date.now();
+      return entry.value;
+    }
+    return undefined;
+  }
+
+  remove(key: string) {
+    this.map.delete(key);
+  }
+
+  toJSON(): Record<string, any> {
+    return Object.fromEntries(this.map.entries());
+  }
+
+  private getOldestKey(): string | undefined {
+    let oldestKey: string | undefined;
+    let oldestTimestamp: number | undefined;
+
+    for (const [key, entry] of this.map.entries()) {
+      if (!oldestTimestamp || entry.la < oldestTimestamp) {
+        oldestKey = key;
+        oldestTimestamp = entry.la;
+      }
+    }
+
+    return oldestKey;
+  }
+}

package/plug-api/lib/memory_cache.ts

@@ -0,0 +1,21 @@
+import { LimitedMap } from "./limited_map.ts";
+
+const cache = new LimitedMap<any>(50);
+
+export async function ttlCache<K, V>(
+  key: K,
+  fn: (key: K) => Promise<V>,
+  ttlSecs?: number,
+): Promise<V> {
+  if (!ttlSecs) {
+    return fn(key);
+  }
+  const serializedKey = JSON.stringify(key);
+  const cached = cache.get(serializedKey);
+  if (cached) {
+    return cached;
+  }
+  const result = await fn(key);
+  cache.set(serializedKey, result, ttlSecs * 1000);
+  return result;
+}

package/plug-api/lib/native_fetch.ts

@@ -0,0 +1,6 @@
+declare global {
+  function nativeFetch(
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response>;
+}

package/plug-api/lib/ref.ts

@@ -0,0 +1,275 @@
+import {
+  findNodeMatching,
+  findNodeOfType,
+  type ParseTree,
+  renderToText,
+} from "@silverbulletmd/silverbullet/lib/tree";
+
+/**
+ * Represents a path with an extension. This is a little cursed, but enforces
+ * that people check the path before setting it. For navigation logic the empty
+ * path will point to the index page. This could differ for e.g. for the
+ * wikilink logic where it points to the currentPage
+ */
+export type Path = `${string}.${string}` | "";
+
+/**
+ * Represents a reference to a page or document, with optional position, anchor and header
+ */
+export type Ref = {
+  path: Path;
+  meta?: boolean;
+
+  details?:
+    | { type: "position"; pos: number }
+    | { type: "linecolumn"; line: number; column: number }
+    | { type: "header"; header: string };
+};
+
+/**
+ * Determines the file extension of a ref. It will only return the last
+ * extension, so `foo.tar.gz` resolves to `gz`
+ * @returns The file extension WITHOUT the dot
+ */
+export function getPathExtension(path: Path): string {
+  // If the ref links to the the file it's on (i.e. path === ""), it's safe to assume it's a link to a "md" page
+  return path !== "" ? path.split(".").pop()!.toLowerCase() : "md";
+}
+
+/**
+ * Renders a path into a "name". This means it removes the extension for `.md` path
+ */
+export function getNameFromPath(path: Path): string {
+  return encodeRef({ path });
+}
+
+/**
+ * Determines there a ref points to a markdown file
+ */
+export function isMarkdownPath(path: Path): boolean {
+  return getPathExtension(path) === "md";
+}
+
+/**
+ * Adds an `md` extension to any path without an extension or a path ending in
+ * `.conflicted`, except to the empty path
+ * @param path The path to normalize. Cannot contain any position or header
+ * addons
+ */
+function normalizePath(path: string): Path {
+  if (path.startsWith("/")) {
+    path = path.slice(1);
+  }
+
+  if (/.+\.[a-zA-Z0-9]+$/.test(path) || path === "") {
+    return path as Path;
+  }
+
+  return `${path}.md`;
+}
+
+/**
+ * Determines wether a name conforms to all the requirments.
+ */
+export function isValidName(name: string): boolean {
+  const ref = parseToRef(name);
+
+  // 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;
+}
+
+/**
+ * Determines wether a path conforms to all the requirments.
+ */
+export function isValidPath(path: string): path is Path {
+  const ref = parseToRef(path);
+
+  return !!ref && ref.path === path;
+}
+
+/**
+ * ONLY TOUCH THIS IF YOU REALLY KNOW WHAT YOU ARE DOING. THIS REGEX IS INTEGRAL
+ * 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>.*))?$/;
+
+/**
+ * Parses a reference string into a ref object.
+ * @returns A ref or if the parsing fails null
+ */
+export function parseToRef(stringRef: string): Ref | null {
+  const match = stringRef.match(refRegex);
+  if (!match || !match.groups) {
+    return null;
+  }
+
+  const groups = match.groups;
+
+  const ref: Ref = { path: normalizePath(groups.path) };
+
+  if (groups.meta) {
+    ref.meta = true;
+  }
+
+  if (groups.pos !== undefined) {
+    ref.details = {
+      type: "position",
+      pos: parseInt(groups.pos),
+    };
+  } else if (groups.line !== undefined) {
+    ref.details = {
+      type: "linecolumn",
+      line: parseInt(groups.line),
+      column: groups.col !== undefined ? parseInt(groups.col) : 1,
+    };
+  } else if (groups.header !== undefined) {
+    ref.details = {
+      type: "header",
+      header: groups.header,
+    };
+  }
+
+  return ref;
+}
+
+/**
+ * The inverse of {@link parseToRef}, encodes a ref object into a reference string.
+ * It tries to produce the shortest valid representation
+ */
+export function encodeRef(ref: Ref): string {
+  let stringRef: string = ref.path;
+
+  if (isMarkdownPath(ref.path)) {
+    stringRef = stringRef.slice(0, -3);
+  }
+
+  if (ref.details?.type === "linecolumn") {
+    stringRef += `@L${ref.details.line}`;
+
+    if (ref.details.column !== 1) {
+      stringRef += `C${ref.details.column}`;
+    }
+  } else if (ref.details?.type === "position") {
+    stringRef += `@${ref.details.pos}`;
+  } else if (ref.details?.type === "header") {
+    stringRef += `#${ref.details.header}`;
+  }
+
+  return stringRef;
+}
+
+/**
+ * Uses a parseTree and a ref pointing to a position inside it to determine the
+ * offset from the start inside it, using {@link getOffsetFromHeader} and
+ * {@link getOffsetFromLineColumn}
+ * @param text If provided the parseTree won't be rendered back to text
+ * @returns The offset in the file if it's able to determine it, otherwise -1
+ */
+export function getOffsetFromRef(
+  parseTree: ParseTree,
+  ref: Ref,
+  text?: string,
+): number {
+  if (!ref.details) {
+    return -1;
+  }
+
+  switch (ref.details.type) {
+    case "position":
+      return ref.details.pos;
+    case "linecolumn":
+      return getOffsetFromLineColumn(
+        text ?? renderToText(parseTree),
+        ref.details.line,
+        ref.details.column,
+      );
+    case "header": {
+      return getOffsetFromHeader(parseTree, ref.details.header);
+    }
+  }
+}
+
+/**
+ * Find the header inside a {@link ParseTree} and returns the position the end
+ * of the header
+ * @param parseTree The parse tree. Can e.g. be generate using
+ * `markdown.parseMarkdown`
+ * @param header The header, spaces at the start or end are ignored
+ * @returns The position of the header inside the document, if it can't be found
+ * -1
+ */
+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)
+        .slice(mark.to - mark.from)
+        .trimStart() === header.trim();
+    },
+  );
+
+  if (!node) {
+    return -1;
+  }
+
+  return node.to ?? -1;
+}
+
+/**
+ * Calculates the character offset from a line and column position. If the
+ * position is out of bounds, it does a best-effort job returning a position.
+ * @param text The text which is used to determine the offset. Only `\n` are
+ * considered line breaks.
+ * @param line The line number of the described position. Starts at 1
+ * @param column The column number of the described position. Starts at 0
+ */
+export function getOffsetFromLineColumn(
+  text: string,
+  line: number,
+  column: number,
+): number {
+  const lines = text.split("\n");
+
+  const linePos = lines
+    .slice(0, Math.max(line - 1, 0))
+    .map((l) => l.length)
+    .reduce((totalLen, len) => totalLen + len, 0);
+
+  const columnPos = Math.max(
+    0,
+    Math.min(lines[line - 1]?.length ?? 0, column - 1),
+  );
+
+  return linePos + columnPos;
+}
+
+/**
+ * Encodes a page name for use in a URI. Basically does
+ * {@link encodeURIComponent}, but puts slashes back in place.
+ */
+export function encodePageURI(page: string): string {
+  return encodeURIComponent(page).replace(/%2F/g, "/");
+}
+
+/**
+ * Decodes a page name from a URI.
+ */
+export function decodePageURI(page: string): string {
+  return decodeURIComponent(page);
+}

package/plug-api/lib/resolve.ts

@@ -0,0 +1,90 @@
+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("://") &&
+    !url.startsWith("mailto:") &&
+    !url.startsWith("tel:");
+}
+
+/**
+ * Extracts the folder name from a page or document name or a path
+ */
+export function folderName(name: string | Path): string {
+  return name.split("/").slice(0, -1).join("/");
+}
+
+export function fileName(path: Path): Path;
+export function fileName(name: string): string;
+export function fileName(name: string | Path): string | Path {
+  return name.split("/").pop()!;
+}
+
+const builtinPrefixes = [
+  "tag:",
+  "search:",
+];
+
+/**
+ * Builtin pages are pages which SB should automatically consider as existing
+ */
+export function isBuiltinPath(path: Path): boolean {
+  return builtinPrefixes.some((prefix) => path.startsWith(prefix));
+}
+
+/**
+ * Resolves a markdown link url relative to an absolute url. It won't resolve
+ * above the base of the absolute path in the file tree. This means excess `..`
+ * will be dropped. It will also only resolve leading `..`
+ */
+export function resolveMarkdownLink(
+  absolute: string,
+  relative: string,
+): string {
+  // These are part of the commonmark spec for urls with spaces inbetween.
+  if (relative.startsWith("<") && relative.endsWith(">")) {
+    relative = relative.slice(1, -1);
+  }
+
+  if (relative.startsWith("/")) {
+    return relative.slice(1);
+  } else {
+    const splitAbsolute = absolute
+      .split("/")
+      .slice(0, -1);
+    const splitRelative = relative
+      .split("/");
+
+    while (splitRelative && splitRelative[0] === "..") {
+      splitAbsolute.pop();
+      splitRelative.shift();
+    }
+
+    return [...splitAbsolute, ...splitRelative].join("/") as Path;
+  }
+}
+
+/**
+ * Turns an absolute path into a relative path, relative to some base directory. USE WITH CAUTION, definitely buggy
+ */
+export function absoluteToRelativePath(base: string, absolute: string): string {
+  // Remove leading /
+  base = base.startsWith("/") ? base.slice(1) : base;
+  absolute = absolute.startsWith("/") ? absolute.slice(1) : absolute;
+
+  const splitAbsolute = absolute.split("/");
+  const splitBase = base.split("/");
+  splitBase.pop();
+
+  // TODO: This is definitely not robust
+  while (splitBase && splitBase[0] === splitAbsolute[0]) {
+    splitBase.shift();
+    splitAbsolute.shift();
+  }
+
+  splitBase.fill("..");
+
+  return [...splitBase, ...splitAbsolute].join("/");
+}

package/plug-api/lib/tags.ts

@@ -0,0 +1,15 @@
+/** 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
+    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
+      return text.slice(2);
+    } else { // this is correct #<name>
+      return text.slice(2, -1);
+    }
+  } else { // this is just #name
+    return text.slice(1);
+  }
+}

package/plug-api/lib/transclusion.ts

@@ -0,0 +1,122 @@
+import {
+  isLocalURL,
+  resolveMarkdownLink,
+} from "@silverbulletmd/silverbullet/lib/resolve";
+import {
+  mdLinkRegex,
+  wikiLinkRegex,
+} from "../../client/markdown_parser/constants.ts";
+import {
+  getNameFromPath,
+  parseToRef,
+} from "@silverbulletmd/silverbullet/lib/ref";
+
+export type LinkType = "wikilink" | "markdownlink";
+/**
+ * Represents a transclusion
+ */
+export type Transclusion = {
+  url: string;
+  alias: string;
+  dimension?: ContentDimensions;
+  linktype: LinkType;
+};
+/**
+ * Describes the dimensions of a transclusion, if provided through the alias.
+ * Can be parsed from the alias using {@link parseDimensionFromAlias}
+ */
+export type ContentDimensions = {
+  width?: number;
+  height?: number;
+};
+
+/**
+ * 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 } {
+  let alias: string;
+  let dim: ContentDimensions | undefined;
+  if (text.includes("|")) {
+    const [aliasPart, dimPart] = text.split("|");
+    alias = aliasPart;
+    const [width, height] = dimPart.split("x");
+    dim = {};
+    if (width) {
+      dim.width = parseInt(width);
+    }
+    if (height) {
+      dim.height = parseInt(height);
+    }
+  } else if (/^[x\d]/.test(text)) {
+    const [width, height] = text.split("x");
+    dim = {};
+    if (width) {
+      dim.width = parseInt(width);
+    }
+    if (height) {
+      dim.height = parseInt(height);
+    }
+    alias = "";
+  } else {
+    alias = text;
+  }
+
+  return { alias, dimension: dim };
+}
+
+/**
+ * Parses a transclusion of the type `![[]]` or `![]()`
+ * @param text
+ */
+export function parseTransclusion(
+  text: string,
+): Transclusion | null {
+  let url, alias = undefined;
+  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;
+  wikiLinkRegex.lastIndex = 0;
+  let match: RegExpMatchArray | null = null;
+  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);
+    linktype = "wikilink";
+  } else {
+    // We found no match
+    return null;
+  }
+
+  let dimension: ContentDimensions | undefined;
+  if (alias) {
+    ({ alias, dimension: dimension } = parseDimensionFromAlias(alias));
+  } else {
+    alias = "";
+  }
+
+  return {
+    url,
+    alias,
+    dimension,
+    linktype,
+  };
+}
+
+export function nameFromTransclusion(t: Transclusion): string {
+  const ref = parseToRef(t.url);
+  if (!ref) {
+    throw new Error(`Cannot extract name from transclusion: ${t.url}`);
+  }
+  return getNameFromPath(ref.path);
+}