forks/sorcery

git clone https://git.gae.moe/forks/sorcery

Charlotte Somrender tip tree/blob views on clientside (big rework)7e9177b2026-09-15

/**
 * where views live. the static page is the fallback and the hash is a delta
 * on it: pieces missing from the hash (revision, path, kind) come from the
 * pathname, so `/u/r/ref/main/blob/x#history` is x's history from main's tip,
 * `/u/r/ref/main/blob/x#<oid>` is x at that commit, and `/u/r/ref/main/blob/x`
 * alone is x at the tip.
 */
import type { GitRepo } from "./git/repo.ts";

export type ViewKind = "tree" | "blob" | "history" | "commit" | "language";
/** for `language`, `path` is the single language id */
export interface View {
  kind: ViewKind;
  oid: string;
  path: string[];
}

/** what the pathname says, plus the ref it stands for */
export interface Page {
  base: string;
  /** the ref's root page: `/u/r/` when that is where we are, else `/u/r/ref/<ref>/` */
  rootBase: string;
  /** where the ref's tree and blob pages live: always `/u/r/ref/<ref>/` */
  refBase: string;
  tip: string | null;
  kind: "tree" | "blob";
  path: string[];
}

export interface Site {
  repo: GitRepo;
  page: Page;
  name: string;
}

const OID = "([0-9a-f]{40}|[0-9a-f]{64})";
export const encodePath = (path: string[]) => path.map(encodeURIComponent).join("/");
const decodePath = (path: string) => path.split("/").filter(Boolean).map(decodeURIComponent);

/** `ref` and `tip` come from `<main data-ref data-tip>`; the ref's pages are
 * the only ones `tip` speaks for, see `withinRef` */
export function pageAt(pathname: string, ref: string | null, tip: string | null): Page {
  const [user, repo, ...rest] = pathname.split("/").filter(Boolean);
  const base = `/${user}/${repo}`;
  if (rest[0] !== "ref") {
    const refBase = ref ? `${base}/ref/${encodePath(ref.split("/"))}/` : `${base}/`;
    // only the root page shows the ref; `/u/r/refs` and the like do not
    return { base, rootBase: `${base}/`, refBase, tip: rest.length === 0 ? tip : null, kind: "tree", path: [] };
  }
  // ref names may contain slashes, so the ref runs up to the tree/blob marker
  const marker = rest.findIndex((seg, i) => i > 1 && (seg === "tree" || seg === "blob"));
  const refBase = `${base}/${(marker < 0 ? rest : rest.slice(0, marker)).join("/")}/`;
  const page = { base, rootBase: refBase, refBase, tip };
  if (marker < 0) return { ...page, kind: "tree", path: [] };
  return { ...page, kind: rest[marker] as "tree" | "blob", path: decodePath(rest.slice(marker + 1).join("/")) };
}

/** whether `pathname` is a page of the same ref as `page`, so that `page.tip`
 * stands for it too */
export const withinRef = (page: Page, pathname: string) =>
  page.tip !== null && (pathname === page.rootBase || pathname.startsWith(page.refBase));

/** what the pathname alone shows: the page's own path at the tip */
export const pageView = (page: Page): View | null =>
  page.tip ? { kind: page.kind, oid: page.tip, path: page.path } : null;

export const viewKey = (view: View | null) => view ? [view.kind, view.oid, ...view.path].join("/") : "";

/** whether `view` is what the page's pathname alone shows, i.e. its url has no hash */
export const isPageView = (page: Page, view: View) => viewKey(view) === viewKey(pageView(page));

/** the hash as a delta on the page; a hash that is no route (`#L12`) leaves
 * the page's own view */
export function viewAt(page: Page, hash: string): View | null {
  const match = (pattern: string) => hash.match(new RegExp(`^#${pattern}$`));
  let m: RegExpMatchArray | null;
  if ((m = match(OID))) return { kind: page.kind, oid: m[1], path: page.path };
  if ((m = match(`commit/${OID}`))) return { kind: "commit", oid: m[1], path: [] };
  if ((m = match(`history(?:/${OID})?`))) {
    const oid = m[1] ?? page.tip;
    return oid ? { kind: "history", oid, path: page.path } : null;
  }
  if ((m = match(`language/([a-z0-9-]+)(?:/${OID})?`))) {
    const oid = m[2] ?? page.tip;
    return oid ? { kind: "language", oid, path: [m[1]] } : null;
  }
  if ((m = match(`(tree|blob|history)/${OID}/(.*)`))) {
    return { kind: m[1] as ViewKind, oid: m[2], path: decodePath(m[3]) };
  }
  if ((m = match(`tree/${OID}`))) return { kind: "tree", oid: m[1], path: [] };
  return pageView(page);
}

/**
 * the shortest url for `view` that is still a real page without JS: the
 * static page itself when it shows the same thing, else the closest static
 * page with the difference in the hash. `atTip` is what `view.path` is at
 * the page's tip, if anything; hash-only results keep the current pathname.
 */
export function canonical(page: Page, view: View, atTip: "tree" | "blob" | null): string {
  const { kind, oid, path } = view;
  const rev = oid === page.tip ? "" : `/${oid}`;
  const pageFor = (kind: "tree" | "blob") =>
    kind === "blob"
      ? `${page.refBase}blob/${encodePath(path)}`
      : path.length > 0
      ? `${page.refBase}tree/${encodePath(path)}/`
      : page.rootBase;
  switch (kind) {
    case "commit":
      return `#commit/${oid}`;
    case "language":
      return `${page.rootBase}#language/${path[0]}${rev}`;
    case "history":
      return atTip ? `${pageFor(atTip)}#history${rev}` : `#history/${oid}/${encodePath(path)}`;
    default:
      return atTip === kind
        ? `${pageFor(kind)}${oid === page.tip ? "" : `#${oid}`}`
        : `#${kind}/${oid}/${encodePath(path)}`;
  }
}