contour-deck 0.0.0-stage → 0.1.0

package/dist/astro/host.js

@@ -0,0 +1,116 @@
+/**
+ * What a host page does around the core, written once: open the deck when the URL or a control asks
+ * for it, close it on exit, and send old reveal.js links to their new position.
+ * `Deck.astro` calls this; a plain HTML host can call it too.
+ *
+ * | Host markup                              | Meaning                                                      |
+ * | ---------------------------------------- | ------------------------------------------------------------ |
+ * | `[data-ct-host]`                         | wrapper of one `[data-ct-deck]`                              |
+ * | `data-ct-doc-class="prose"`              | classes the wrapper carries only while the deck is closed    |
+ * | `data-ct-paging`, `data-ct-overview`     | the `paging` and `overview` options of the core              |
+ * | `data-ct-legacy`                         | accept `?view=slides&slide=h.v`                              |
+ * | `[data-ct-start]`, `[data-ct-start="notes"]` | a control that opens the deck or its notes view: inside a host for that deck, elsewhere for the first deck of the page |
+ */
+import { createDeck } from "../core/index.js";
+import { legacyAt, parseLegacy, readLegacy } from "./legacy.js";
+const mounted = new WeakMap();
+function optionsOf(host) {
+    const { ctPaging, ctOverview } = host.dataset;
+    return {
+        ...(ctPaging === "free" || ctPaging === "snap" ? { paging: ctPaging } : {}),
+        ...(ctOverview === "3d" || ctOverview === "flat" ? { overview: ctOverview } : {}),
+    };
+}
+/**
+ * Rewrites `?view=slides&slide=h.v` to `?view=deck&at=b.s.p` in place and returns nothing:
+ * the core then reads its own parameters. An old link without a match opens the outline.
+ */
+function adoptLegacyUrl(root) {
+    const url = new URL(location.href);
+    if (url.searchParams.get("view") !== "slides")
+        return;
+    const old = parseLegacy(url.searchParams.get("slide") ?? "0");
+    const at = old && legacyAt(readLegacy(root), old.h, old.v);
+    url.searchParams.delete("slide");
+    url.searchParams.set("view", "deck");
+    if (at)
+        url.searchParams.set("at", at);
+    history.replaceState(history.state, "", url);
+}
+/** Wires one `[data-ct-host]`. Mounting the same element twice returns the first host. */
+export function mount(host) {
+    const known = mounted.get(host);
+    if (known)
+        return known;
+    const root = host.querySelector("[data-ct-deck]");
+    if (!root)
+        return null;
+    const docClasses = (host.dataset.ctDocClass ?? "").split(/\s+/).filter(Boolean);
+    const abort = new AbortController();
+    let deck = null;
+    let opener = null;
+    function close() {
+        if (!deck)
+            return;
+        deck.destroy();
+        deck = null;
+        host.classList.add(...docClasses);
+        opener?.focus({ preventScroll: true });
+        opener = null;
+    }
+    function open(options = {}) {
+        if (deck)
+            return;
+        // Document-view classes (a prose class, say) would restyle the shell and the stage, so they wait outside.
+        host.classList.remove(...docClasses);
+        try {
+            deck = createDeck(root, { ...optionsOf(host), ...options });
+        }
+        catch (error) {
+            host.classList.add(...docClasses);
+            throw error;
+        }
+        deck.on("exit", close);
+    }
+    // In the capture phase: a client-side router that listens on the document would otherwise
+    // take a start link as a navigation before this handler sees it.
+    document.addEventListener("click", event => {
+        const control = event.target.closest?.("[data-ct-start]");
+        if (!control || event.defaultPrevented)
+            return;
+        // A modified click on a start link opens it in a new tab or window, as any link.
+        if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+            return;
+        // A control inside a host opens that deck; one elsewhere opens the first deck of the page.
+        if ((control.closest("[data-ct-host]") ?? document.querySelector("[data-ct-host]")) !== host)
+            return;
+        event.preventDefault();
+        opener = control;
+        open({ view: control.dataset.ctStart === "notes" ? "notes" : "deck" });
+    }, { capture: true, signal: abort.signal });
+    if ("ctLegacy" in host.dataset)
+        adoptLegacyUrl(root);
+    const view = new URLSearchParams(location.search).get("view");
+    if (view === "deck" || view === "notes")
+        open();
+    const api = {
+        get deck() {
+            return deck;
+        },
+        open,
+        close,
+        unmount() {
+            close();
+            abort.abort();
+            mounted.delete(host);
+        },
+    };
+    mounted.set(host, api);
+    return api;
+}
+/** Mounts every `[data-ct-host]` in the document that is not mounted yet. */
+export function mountAll() {
+    return Array.from(document.querySelectorAll("[data-ct-host]"))
+        .map(mount)
+        .filter((host) => host !== null);
+}

package/dist/astro/legacy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Old reveal.js links (`?view=slides&slide=h.v`) to a Contour position, read from the
+ * `data-legacy` and `data-legacy-v` attributes of docs/CONTRACT.md.
+ */
+/** One slide as the old deck knew it: its horizontal index, the vertical index of its first page, its page count. */
+export interface LegacySlide {
+    legacy: number;
+    legacyV: number;
+    pages: number;
+}
+/** `"11"` or `"11.2"` to the old indexes; `null` when the text is not an old slide parameter. */
+export declare function parseLegacy(slide: string): {
+    h: number;
+    v: number;
+} | null;
+/**
+ * The `?at=` value (1-based `b.s.p`) of the old slide `h.v`. `blocks[b][s]` describes slide `s` of block `b`.
+ * A `v` past the end of the old stack lands on its last page; an `h` the deck never had gives `null`.
+ */
+export declare function legacyAt(blocks: LegacySlide[][], h: number, v: number): string | null;
+/** Reads the legacy table of a deck element. Slides without `data-legacy` never match. */
+export declare function readLegacy(root: Element): LegacySlide[][];

package/dist/astro/legacy.js

@@ -0,0 +1,42 @@
+/**
+ * Old reveal.js links (`?view=slides&slide=h.v`) to a Contour position, read from the
+ * `data-legacy` and `data-legacy-v` attributes of docs/CONTRACT.md.
+ */
+/** `"11"` or `"11.2"` to the old indexes; `null` when the text is not an old slide parameter. */
+export function parseLegacy(slide) {
+    const match = /^(\d+)(?:\.(\d+))?$/.exec(slide.trim());
+    return match ? { h: Number(match[1]), v: Number(match[2] ?? 0) } : null;
+}
+/**
+ * The `?at=` value (1-based `b.s.p`) of the old slide `h.v`. `blocks[b][s]` describes slide `s` of block `b`.
+ * A `v` past the end of the old stack lands on its last page; an `h` the deck never had gives `null`.
+ */
+export function legacyAt(blocks, h, v) {
+    let found;
+    for (const [b, slides] of blocks.entries()) {
+        for (const [s, slide] of slides.entries()) {
+            if (slide.legacy !== h)
+                continue;
+            // Slides split from one old stack share `h`; the one that holds `v` starts at or before it.
+            if (!found || (slide.legacyV <= v && slide.legacyV >= found.slide.legacyV))
+                found = { b, s, slide };
+        }
+    }
+    if (!found)
+        return null;
+    const page = Math.min(Math.max(v - found.slide.legacyV, 0), found.slide.pages - 1);
+    return `${found.b + 1}.${found.s + 1}.${page + 1}`;
+}
+/** Reads the legacy table of a deck element. Slides without `data-legacy` never match. */
+export function readLegacy(root) {
+    const childrenWith = (el, attribute) => Array.from(el.children).filter(child => child.hasAttribute(attribute));
+    const index = (el, attribute, missing) => {
+        const value = el.getAttribute(attribute);
+        return value !== null && /^\d+$/.test(value) ? Number(value) : missing;
+    };
+    return childrenWith(root, "data-ct-block").map(block => childrenWith(block, "data-ct-slide").map(slide => ({
+        legacy: index(slide, "data-legacy", -1),
+        legacyV: index(slide, "data-legacy-v", 0),
+        pages: childrenWith(slide, "data-ct-page").length,
+    })));
+}

package/dist/core/deck.d.ts

@@ -0,0 +1,2 @@
+import type { Deck, DeckOptions } from "./types.js";
+export declare function createDeck(root: HTMLElement, options?: DeckOptions): Deck;