benjivers/notes Public Public: anyone can read this; nobody can change it.

/**

 * What a vault knows about itself, from its notes alone: which note links

 * to which, what links back, which tags are in use, how the whole thing

 * hangs together as a graph, and what a search finds. Pure functions over a

 * list of notes — no database, no identity — so every door that shows a

 * vault shows the same one, and a test needs nothing but notes.

 *

 * Links are by title, the way a person writes them: `[[Some note]]`,

 * matched without regard to case. The markdown itself is `static/md.js`,

 * shared with the browser.

 */

// @ts-ignore — plain JS module, shared verbatim with the browser.

import * as md from "../static/md.js";

export interface VaultNote {

  readonly id: number;

  readonly title: string;

  readonly body: string;

  readonly pinned: number;

  readonly updated_at: string;

}

export interface Heading {

  readonly level: number;

  readonly text: string;

  readonly id: string;

}

export const links = (body: string): string[] => md.links(body);

export const tags = (body: string): string[] => md.tags(body);

export const headings = (body: string): Heading[] => md.headings(body);

const key = (title: string): string => title.trim().toLowerCase();

/** Title (any case) → note. */

export const byTitle = <T extends VaultNote>(notes: readonly T[]) =>

  new Map(notes.map((n) => [key(n.title), n]));

/** A note's address. */

export const hrefOf = (note: { readonly id: number }): string => `/n/${note.id}`;

/** A note's markdown as HTML, its links pointed at the notes they name. */

export function renderNote(

  body: string,

  notes: readonly VaultNote[],

  base = "",

): string {

  const titles = byTitle(notes);

  return md.render(body, {

    base,

    resolve: (title: string) => {

      const found = titles.get(key(title));

      return found === undefined ? null : hrefOf(found);

    },

  });

}

/** The notes that link to `note`, by title. */

export function backlinks<T extends VaultNote>(

  note: VaultNote,

  notes: readonly T[],

): T[] {

  const me = key(note.title);

  return notes.filter(

    (n) => n.id !== note.id && links(n.body).some((l) => key(l) === me),

  );

}

/** What `note` links to: the notes that exist, and the titles that do not yet. */

export function outgoing<T extends VaultNote>(

  note: VaultNote,

  notes: readonly T[],

): { found: T[]; missing: string[] } {

  const titles = byTitle(notes);

  const found: T[] = [];

  const missing: string[] = [];

  for (const title of links(note.body)) {

    const hit = titles.get(key(title));

    if (hit === undefined) missing.push(title);

    else if (hit.id !== note.id) found.push(hit);

  }

  return { found, missing };

}

/** Every tag in the vault with how many notes carry it, most used first. */

export function tagCounts(notes: readonly VaultNote[]): { tag: string; count: number }[] {

  const counts = new Map<string, number>();

  for (const n of notes)

    for (const t of tags(n.body)) counts.set(t, (counts.get(t) ?? 0) + 1);

  return [...counts]

    .map(([tag, count]) => ({ tag, count }))

    .sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag));

}

export interface Graph {

  readonly nodes: { id: number; title: string; links: number }[];

  readonly edges: [number, number][];

}

/** The vault as nodes and undirected edges, for the graph view. */

export function graph(notes: readonly VaultNote[]): Graph {

  const titles = byTitle(notes);

  const seen = new Set<string>();

  const edges: [number, number][] = [];

  const degree = new Map<number, number>();

  for (const n of notes)

    for (const title of links(n.body)) {

      const to = titles.get(key(title));

      if (to === undefined || to.id === n.id) continue;

      const pair = n.id < to.id ? `${n.id}-${to.id}` : `${to.id}-${n.id}`;

      if (seen.has(pair)) continue;

      seen.add(pair);

      edges.push([n.id, to.id]);

      degree.set(n.id, (degree.get(n.id) ?? 0) + 1);

      degree.set(to.id, (degree.get(to.id) ?? 0) + 1);

    }

  return {

    nodes: notes.map((n) => ({ id: n.id, title: n.title, links: degree.get(n.id) ?? 0 })),

    edges,

  };

}

export interface Hit<T> {

  readonly note: T;

  /** A line of the body around the first match, plain text. */

  readonly snippet: string;

}

/**

 * Search: every word must appear in the title or body (any case); `#tag`

 * or `tag:name` must be a tag the note carries; a phrase in quotes is

 * matched whole. Title matches rank first, then the most recently changed.

 */

export function search<T extends VaultNote>(

  notes: readonly T[],

  query: string,

): Hit<T>[] {

  const wanted: string[] = [];

  const tagged: string[] = [];

  for (const m of query.matchAll(/"([^"]+)"|(\S+)/g)) {

    const word = (m[1] ?? m[2] ?? "").toLowerCase();

    const tag = /^(?:#|tag:)(.+)$/.exec(word)?.[1];

    if (tag !== undefined && m[1] === undefined) tagged.push(tag);

    else if (word !== "") wanted.push(word);

  }

  if (wanted.length === 0 && tagged.length === 0) return [];

  const hits: (Hit<T> & { title: boolean })[] = [];

  for (const note of notes) {

    const title = note.title.toLowerCase();

    const body = note.body.toLowerCase();

    if (!wanted.every((w) => title.includes(w) || body.includes(w))) continue;

    if (tagged.length > 0) {

      const has = tags(note.body);

      // A tag matches itself and its children: #work finds #work/acme.

      if (!tagged.every((t) => has.some((h) => h === t || h.startsWith(`${t}/`)))) continue;

    }

    hits.push({

      note,

      snippet: snippet(note.body, wanted[0] ?? (tagged[0] === undefined ? "" : `#${tagged[0]}`)),

      title: wanted.length > 0 && wanted.every((w) => title.includes(w)),

    });

  }

  hits.sort(

    (a, b) =>

      Number(b.title) - Number(a.title) ||

      b.note.updated_at.localeCompare(a.note.updated_at),

  );

  return hits.map(({ note, snippet }) => ({ note, snippet }));

}

function snippet(body: string, word: string): string {

  const at = word === "" ? -1 : body.toLowerCase().indexOf(word);

  if (at < 0) return body.split("\n").find((l) => l.trim() !== "")?.trim().slice(0, 160) ?? "";

  const start = Math.max(0, body.lastIndexOf("\n", at) + 1, at - 70);

  const endLine = body.indexOf("\n", at);

  const end = Math.min(endLine < 0 ? body.length : endLine, at + 90);

  return `${start > 0 && body[start - 1] !== "\n" ? "…" : ""}${body.slice(start, end).trim()}${end < (endLine < 0 ? body.length : endLine) ? "…" : ""}`;

}

/**

 * The body with every link to `from` pointed at `to` instead, keeping any

 * alias and heading: what a rename does to the notes that link to it.

 */

export function relink(body: string, from: string, to: string): string {

  const old = key(from);

  return body.replace(

    /(!?)\[\[([^\[\]\n|#]+?)((?:#[^\[\]\n|]*)?)((?:\|[^\[\]\n]+?)?)\]\]/g,

    (whole, embed: string, title: string, heading: string, alias: string) =>

      key(title) === old ? `${embed}[[${to}${heading}${alias}]]` : whole,

  );

}

/** A plain-text preview of a note's first words, for lists. */

export function excerpt(body: string, max = 120): string {

  const text = (md.frontmatter(body)?.body ?? body)

    .replace(/^(```|~~~)[\s\S]*?^\1/gm, "")

    .replace(/^#{1,6}\s+/gm, "")

    .replace(/\[\[([^\]|]+)\|([^\]]+)\]\]/g, "$2")

    .replace(/\[\[([^\]]+)\]\]/g, "$1")

    .replace(/[*_=~`>]/g, "")

    .replace(/\s+/g, " ")

    .trim();

  return text.length > max ? `${text.slice(0, max - 1)}…` : text;

}