@hajimism/dek 0.1.0

package/src/core/url-attributes.ts

@@ -0,0 +1,103 @@
+/**
+ * Which attributes name a URL, and where in the value each URL is written. Lint checks exactly
+ * these, and the build inlines exactly these, so a reference that passes one never breaks the other.
+ */
+
+/**
+ * What the page does with a URL: a `resource` is loaded to draw the slide, so it must exist and
+ * live in the deck's `assets/`; a `link` is only followed when someone activates it.
+ */
+export type UrlUse = "resource" | "link";
+
+/**
+ * Every attribute that names a URL, first match wins. `list` marks a `srcset`, which names one URL
+ * per candidate. `href` loads a resource only in SVG; elsewhere it is a link, and `<link>` in a
+ * document's head points at the theme, which the build replaces.
+ */
+const URL_ATTRIBUTES: ReadonlyArray<{
+  attr: string;
+  use: UrlUse;
+  tags?: readonly string[];
+  list?: boolean;
+}> = [
+  { attr: "src", use: "resource" },
+  { attr: "srcset", use: "resource", list: true },
+  { attr: "imagesrcset", use: "resource", list: true },
+  { attr: "poster", use: "resource" },
+  { attr: "background", use: "resource" },
+  { attr: "data", use: "resource", tags: ["object"] },
+  { attr: "href", use: "resource", tags: ["image", "use", "feimage"] },
+  { attr: "xlink:href", use: "resource" },
+  { attr: "href", use: "link" },
+  { attr: "action", use: "link" },
+  { attr: "formaction", use: "link" },
+];
+
+/** Whether `attr` on a `tag` element names a URL. */
+export function isUrlAttribute(tag: string, attr: string): boolean {
+  return urlAttribute(tag, attr) !== undefined;
+}
+
+function urlAttribute(tag: string, attr: string): (typeof URL_ATTRIBUTES)[number] | undefined {
+  return URL_ATTRIBUTES.find(
+    (entry) => entry.attr === attr && (entry.tags === undefined || entry.tags.includes(tag)),
+  );
+}
+
+/**
+ * The URLs of a `srcset`, each with its offset in the value, parsed the way the HTML standard
+ * does: a URL runs to the next whitespace, a trailing comma ends it, and the descriptors after it
+ * run to the next comma. So `data:` URIs keep their commas.
+ */
+export function srcsetUrls(value: string): Array<{ url: string; offset: number }> {
+  const candidates: Array<{ url: string; offset: number }> = [];
+  let index = 0;
+  while (index < value.length) {
+    while (index < value.length && /[\s,]/.test(value[index] ?? "")) {
+      index++;
+    }
+    const start = index;
+    while (index < value.length && !/\s/.test(value[index] ?? "")) {
+      index++;
+    }
+    let url = value.slice(start, index);
+    if (url.endsWith(",")) {
+      url = url.replace(/,+$/, "");
+    } else {
+      let depth = 0;
+      for (; index < value.length; index++) {
+        const char = value[index];
+        if (char === "(") {
+          depth++;
+        } else if (char === ")") {
+          depth = Math.max(0, depth - 1);
+        } else if (char === "," && depth === 0) {
+          break;
+        }
+      }
+    }
+    if (url) {
+      candidates.push({ url, offset: start });
+    }
+  }
+  return candidates;
+}
+
+/** The URLs an attribute names, each with its offset into the value; none when it names no URL. */
+export function attributeUrls(
+  tag: string,
+  attr: string,
+  value: string,
+): { use: UrlUse; urls: Array<{ url: string; offset: number }> } | undefined {
+  const entry = urlAttribute(tag, attr);
+  const url = value.trim();
+  if (!entry || !url) {
+    return undefined;
+  }
+  return {
+    use: entry.use,
+    urls: entry.list
+      ? srcsetUrls(value)
+      : [{ url, offset: value.length - value.trimStart().length }],
+  };
+}

package/src/core/video-document.ts

@@ -0,0 +1,15 @@
+import { loadConfig } from "./config.ts";
+import { renderDeckDocument } from "./document.ts";
+import type { ResolvedDeck } from "./resolve.ts";
+
+/**
+ * The whole deck as `dekc video` plays it: every slide, assets inlined, no notes, and the player
+ * runtime that walks it. Motion stills, morph frames and the video itself all run on this page.
+ */
+export function videoDocument({ project, deck }: ResolvedDeck, playerScript: string): string {
+  return renderDeckDocument(deck, {
+    config: loadConfig(project.configPath),
+    playerScript,
+    target: { kind: "video" },
+  });
+}

package/src/core/visual-cache.ts

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { cacheDir, deckProjectRoot } from "./path.ts";
+import type { PageAction, PagesResponse, VisualPage } from "./playwright.ts";
+import {
+  isCachedFile,
+  outputDir,
+  readSourceIfExists,
+  removeInside,
+  writeInside,
+} from "./safe-fs.ts";
+
+/** What measuring one page found: its overflows, its texts' contrast, and what its draw threw. */
+export type PageFindings = Required<PagesResponse>;
+
+/**
+ * The code that decides what a page's findings are. A change to any of it can change them, so
+ * its source is part of every key, and a cache written by another dek is never read.
+ */
+const MEASURERS = [
+  "playwright-visual.ts",
+  "slide-measure.ts",
+  "text-contrast.ts",
+  "fill.ts",
+  "overflow.ts",
+  "pseudo-text.ts",
+  "finish-beat.ts",
+  "visual-cache.ts",
+];
+
+let measurerFingerprint: string | undefined;
+
+function measurers(): string {
+  measurerFingerprint ??= createHash("sha256")
+    .update(MEASURERS.map((name) => readFileSync(join(import.meta.dir, name), "utf8")).join("\0"))
+    .digest("hex");
+  return measurerFingerprint;
+}
+
+/**
+ * The findings of each page `--visual` measured, under `.cache/visual`, named by a hash of all
+ * that decides them: the page's HTML, which holds its theme, CSS, script, and assets, the
+ * viewport, the checks asked for, and the code that measures. A page whose name is on disk is not
+ * measured again. Like every cache, it can be deleted: the next run measures everything.
+ */
+export type VisualCache = {
+  key(page: VisualPage): string;
+  read(key: string): PageFindings | undefined;
+  write(key: string, findings: PageFindings): void;
+  /** Removes every entry but `keep`, after a run that measured the whole deck. */
+  prune(keep: Set<string>): void;
+};
+
+export function visualCache(
+  deckDir: string,
+  request: { viewport: { width: number; height: number }; actions: PageAction[] },
+): VisualCache {
+  const root = deckProjectRoot(deckDir);
+  const dir = cacheDir(deckDir, "visual");
+  const pathOf = (key: string): string => join(dir, `${key}.json`);
+  const context = JSON.stringify({ measurers: measurers(), ...request });
+  return {
+    key: (page) =>
+      createHash("sha256")
+        .update(context)
+        .update("\0")
+        .update(JSON.stringify([page.slug, page.step, page.html]))
+        .digest("hex")
+        .slice(0, 32),
+    read: (key) => {
+      const path = pathOf(key);
+      if (!isCachedFile(path)) {
+        return undefined;
+      }
+      try {
+        return JSON.parse(readSourceIfExists(path, root) ?? "") as PageFindings;
+      } catch {
+        return undefined;
+      }
+    },
+    write: (key, findings) => {
+      outputDir(dir, root);
+      writeInside(pathOf(key), JSON.stringify(findings), root);
+    },
+    prune: (keep) => {
+      let entries: string[];
+      try {
+        entries = readdirSync(dir);
+      } catch {
+        return;
+      }
+      for (const name of entries) {
+        if (name.endsWith(".json") && !keep.has(name.slice(0, -".json".length))) {
+          removeInside(join(dir, name), root);
+        }
+      }
+    },
+  };
+}