@hajimism/dek 0.1.0

package/src/cli/shot.ts

@@ -0,0 +1,134 @@
+import { DekError } from "../core/error.ts";
+import { parseMorphAt, shotMorph } from "../core/shot/morph.ts";
+import { type ShotMotion, shotMotion } from "../core/shot/motion.ts";
+import { type ShotFile, shotDeck, shotSheet } from "../core/shot/still.ts";
+import { playerScript } from "../runtime/player.ts";
+import type { ReadableDeck } from "./scope.ts";
+import { usageError } from "./usage.ts";
+
+export type ShotCliResult = {
+  shots: ShotFile[];
+  /** Contact sheets, from --sheet or --motion; what text output prints when present. */
+  sheets?: string[];
+  /** With --motion, each beat's frames and the ms into its go each shows. */
+  motion?: ShotMotion["beats"];
+};
+
+type ShotCommandOptions = {
+  slug?: string;
+  step?: string;
+  to?: string;
+  at?: string;
+  sheet?: boolean;
+  motion?: boolean;
+};
+
+/** What `dekc shot` was asked to take, once its flags are known to fit together. */
+export type ShotMode =
+  | { kind: "still"; slug?: string; step?: string }
+  | { kind: "sheet" }
+  | { kind: "motion"; slug: string; step?: string }
+  | { kind: "morph"; from: string; to: string; at: number };
+
+export async function shotCommand(
+  { project, deck }: ReadableDeck,
+  options: ShotCommandOptions,
+): Promise<ShotCliResult> {
+  const mode = parseShotMode(options);
+  switch (mode.kind) {
+    case "sheet": {
+      const { sheets, shots } = await shotSheet({ project, deck });
+      return { shots, sheets };
+    }
+    case "motion": {
+      const { sheets, beats } = await shotMotion(
+        { project, deck },
+        {
+          slug: mode.slug,
+          ...(mode.step === undefined ? {} : { step: mode.step }),
+          playerScript: await playerScript(),
+        },
+      );
+      return { shots: [], sheets, motion: beats };
+    }
+    case "morph": {
+      const shots = await shotMorph(
+        { project, deck },
+        { from: mode.from, to: mode.to, at: mode.at, playerScript: await playerScript() },
+      );
+      return { shots };
+    }
+    case "still": {
+      const shots = await shotDeck({ project, deck }, { slug: mode.slug, step: mode.step });
+      return { shots };
+    }
+  }
+}
+
+function refuse(message: string, hint: string): never {
+  throw new DekError(message, { hint });
+}
+
+/**
+ * The one mode the flags name: --sheet is the whole deck at its last beats, --motion one slide's
+ * beats, --to a frame of the move to another slide, and none of them a still.
+ */
+export function parseShotMode(options: ShotCommandOptions): ShotMode {
+  const { slug, step, to, at } = options;
+  if (options.sheet && options.motion) {
+    refuse(
+      "--sheet and --motion together",
+      "use one of --sheet and --motion: --sheet tiles every slide, --motion one slide's beats",
+    );
+  }
+  if (options.sheet) {
+    if (to !== undefined || at !== undefined) {
+      refuse("--sheet with --to or --at", "--sheet takes no --to or --at; drop them");
+    }
+    if (step !== undefined) {
+      refuse("--sheet with --step", "--sheet shows every slide at its last beat; drop --step");
+    }
+    if (slug) {
+      refuse(
+        "--sheet with a slug",
+        `--sheet tiles every slide; for one slide's beats, run \`dekc shot ${slug} --motion\``,
+      );
+    }
+    return { kind: "sheet" };
+  }
+  if (options.motion) {
+    if (to !== undefined) {
+      refuse(
+        "--motion with --to",
+        "the move from the slide before is row 1 of --motion; for a jump to any slide, use `dekc shot <a> --to <b>`",
+      );
+    }
+    if (at !== undefined) {
+      refuse("--motion with --at", "--motion holds each beat at several moments; drop --at");
+    }
+    if (!slug) {
+      throw usageError("shot", "--motion needs a slide", { match: "--motion" });
+    }
+    return { kind: "motion", slug, ...(step === undefined ? {} : { step }) };
+  }
+  if (to !== undefined) {
+    if (!slug) {
+      throw usageError("shot", "--to needs the slide it starts from", { match: "--to" });
+    }
+    if (step !== undefined) {
+      refuse(
+        "--to cannot be combined with --step",
+        "a morph frame always starts from the last beat; drop --step",
+      );
+    }
+    return { kind: "morph", from: slug, to, at: parseMorphAt(at) };
+  }
+  if (at !== undefined) {
+    throw usageError("shot", "--at needs --to", { match: "--to" });
+  }
+  return {
+    kind: "still",
+    ...(slug ? { slug } : {}),
+    ...(step === undefined ? {} : { step }),
+  };
+}

package/src/cli/show.ts

@@ -0,0 +1,103 @@
+import { classifyAssetRef } from "../core/assets.ts";
+import { cssUrls, parseCss } from "../core/css.ts";
+import { deckPaths } from "../core/deck-paths.ts";
+import { scanSlideHtml } from "../core/html-scan.ts";
+import { sectionChunks, splitLines } from "../core/lines.ts";
+import { readDeckFile } from "../core/resolve.ts";
+import type { Section } from "../core/schema.ts";
+import { themeExcerpt } from "../core/theme-excerpt.ts";
+import { type ReadableDeck, type RefInfo, requireSection } from "./scope.ts";
+
+/**
+ * Everything one slide is made of, read in one call: enough to learn how it is
+ * built without opening theme.css whole.
+ */
+export type ShowResult = {
+  slug: string;
+  title: string;
+  /** The section as script.md has it, from its `##` heading, beat headings and ids included. */
+  script: string;
+  /** Its beats in order, the ids and positions a `data-step` binds to. */
+  beats: { id?: string; title: string; line: number }[];
+  html: string | null;
+  /** `slides/<slug>.css`. */
+  css: string | null;
+  /** `slides/<slug>.ts`. */
+  ts: string | null;
+  /** The rules of the deck's theme.css this slide uses; null when the deck has no theme.css. */
+  theme: string | null;
+  /** Deck-relative paths of the files the slide references that exist. */
+  assets: string[];
+  /** Set when the deck is a ref. */
+  ref?: RefInfo;
+};
+
+export function showCommand({ deck, ref }: ReadableDeck, slug: string): ShowResult {
+  const section = requireSection(deck, slug);
+
+  const paths = deckPaths(deck.dir);
+  // Through the same link rules as the build: show prints nothing a build would refuse.
+  const read = (path: string): string | null => readDeckFile(deck.dir, path) ?? null;
+  const html = read(paths.slide(slug, ".html"));
+  const css = read(paths.slide(slug, ".css"));
+  const ts = read(paths.slide(slug, ".ts"));
+  const themeCss = read(paths.theme);
+  const scan = html === null ? undefined : scanSlideHtml(html);
+  const sheet = css === null ? undefined : parseCss(css);
+
+  const theme =
+    themeCss === null
+      ? null
+      : themeExcerpt(parseCss(themeCss), {
+          classes: scan?.classes ?? [],
+          ...(scan?.layout !== undefined ? { layout: scan.layout } : {}),
+          ...(sheet ? { css: sheet } : {}),
+        });
+
+  const refs = [
+    ...(scan?.refs.map((ref) => ref.value) ?? []),
+    ...(sheet ? cssUrls(sheet).map((url) => url.value) : []),
+  ];
+
+  return {
+    slug: section.slug,
+    title: section.title,
+    script: sectionSource(deck, section),
+    beats: section.beats.map(({ id, title, line }) => ({ ...(id ? { id } : {}), title, line })),
+    html,
+    css,
+    ts,
+    theme,
+    assets: existingRefs(refs, paths.slides, deck.dir),
+    ...(ref ? { ref } : {}),
+  };
+}
+
+/**
+ * Local references that name a file inside the deck, as sorted deck-relative
+ * paths. theme.css and the slide's own files are left out: show returns them.
+ */
+function existingRefs(values: string[], slidesDir: string, deckDir: string): string[] {
+  const found = new Set<string>();
+  for (const value of values) {
+    const ref = classifyAssetRef(value, { deckDir, from: slidesDir });
+    if (
+      ref.kind === "file" &&
+      ref.deckPath !== "theme.css" &&
+      !ref.deckPath.startsWith("slides/")
+    ) {
+      found.add(ref.deckPath);
+    }
+  }
+  return [...found].sort();
+}
+
+/** The section's lines of script.md, up to the next section, without the blank lines between. */
+function sectionSource(deck: ReadableDeck["deck"], section: Section): string {
+  const sections = deck.deck.sections;
+  const chunk = sectionChunks(
+    splitLines(readDeckFile(deck.dir, deck.scriptPath) ?? ""),
+    sections.map((entry) => entry.line),
+  )[sections.indexOf(section)];
+  return `${(chunk ?? []).join("\n").trimEnd()}\n`;
+}

package/src/cli/sync.ts

@@ -0,0 +1,37 @@
+import { join } from "node:path";
+import { syncDeck } from "../core/sync.ts";
+import { ignoreLocalState } from "./files.ts";
+import type { DecksTarget } from "./scope.ts";
+
+/**
+ * Every file the sync wrote or removed: the decks' slides, then dek's own files, then .gitignore
+ * when it lacked what dek keeps for itself; and the slides it kept though their section is gone,
+ * which lint reports as DEK002.
+ */
+export type SyncCliResult = {
+  created: string[];
+  updated: string[];
+  removed: string[];
+  kept: string[];
+};
+
+export function syncCommand({ project, decks }: DecksTarget): SyncCliResult {
+  const result: SyncCliResult = { created: [], updated: [], removed: [], kept: [] };
+  const dek = { created: [] as string[], updated: [] as string[] };
+  for (const deck of decks) {
+    const synced = syncDeck({ project, deck });
+    result.created.push(...synced.created);
+    result.updated.push(...synced.updated);
+    result.removed.push(...synced.removed);
+    result.kept.push(...synced.kept);
+    // The first deck brings them up to date; the rest find them current.
+    dek.created.push(...synced.dekFiles.created);
+    dek.updated.push(...synced.dekFiles.updated);
+  }
+  result.created.push(...dek.created);
+  result.updated.push(...dek.updated);
+  if (ignoreLocalState(project.root)) {
+    result.updated.push(join(project.root, ".gitignore"));
+  }
+  return result;
+}