@kadal/deck 0.0.0-stage → 0.1.0

package/dist/core/navigation.d.ts

@@ -0,0 +1,74 @@
+import { Column, DeckConfig } from "./model.js";
+declare namespace navigation_d_exports {
+  export { Direction, NavState, Position, Routes, availableRoutes, clampPosition, down, first, formatSlideNumber, goto, initialNav, key, last, left, next, nextClick, prev, prevClick, progressOf, right, setTotal, up };
+}
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ * NAVIGATION
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * Where the deck is and how it got there. `click` is the step within a slide (reveal.js's
+ * fragment index, Slidev's click); `direction` is what the transition reads. Everything is a pure
+ * function of the state and the click totals the runtime reports, so the presenter window, the
+ * live room and the keyboard all drive the same reducer.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+export type Direction = "none" | "forward" | "back" | "up" | "down";
+export interface Position {
+  h: number;
+  v: number;
+  click: number;
+}
+export interface NavState extends Position {
+  direction: Direction;
+  overview: boolean;
+  paused: boolean;
+  autoSliding: boolean;
+  /** Per visible slide: how many clicks the runtime has registered (by "h,v"). */
+  totals: Record<string, number>;
+  /** The position the presenter is at, when this window follows one and is not the presenter. */
+  presenter: Position | null;
+  /** Whether this window follows the presenter's navigation. */
+  follow: boolean;
+  /** A visible slide id → clamped ok; set by `goto` for hash routing. */
+  seq: number;
+}
+export declare const key: (h: number, v: number) => string;
+export declare function initialNav(): NavState;
+export declare function clampPosition(columns: Column[], p: Partial<Position>): Position;
+export interface Routes {
+  left: boolean;
+  right: boolean;
+  up: boolean;
+  down: boolean;
+  prevClick: boolean;
+  nextClick: boolean;
+}
+export declare function availableRoutes(state: NavState, columns: Column[], config: DeckConfig): Routes;
+/** Move to an exact position (a hash, a link, the presenter). Clicks default to 0. */
+export declare function goto(state: NavState, columns: Column[], to: Partial<Position>): NavState;
+export declare function right(state: NavState, columns: Column[], config: DeckConfig): NavState;
+export declare function left(state: NavState, columns: Column[], config: DeckConfig): NavState;
+export declare function down(state: NavState, columns: Column[]): NavState;
+export declare function up(state: NavState, columns: Column[]): NavState;
+export declare function nextClick(state: NavState): NavState;
+export declare function prevClick(state: NavState): NavState;
+/**
+ * `next`: the next click, else the slide beneath, else the next column. In linear mode the deck
+ * reads like a book: every vertical slide is a page. Matches reveal.js's space bar.
+ */
+export declare function next(state: NavState, columns: Column[], config: DeckConfig): NavState;
+/** `prev`: the previous click, else the slide above, else the previous column. */
+export declare function prev(state: NavState, columns: Column[], config: DeckConfig, opts?: {
+  toLastClick?: boolean;
+}): NavState;
+export declare function first(state: NavState, columns: Column[]): NavState;
+export declare function last(state: NavState, columns: Column[]): NavState;
+/** Record the click total the runtime found for a slide; clamps the current click if needed. */
+export declare function setTotal(state: NavState, h: number, v: number, total: number): NavState;
+/** 0 at the first slide, 1 at the last. */
+export declare function progressOf(state: NavState, columns: Column[]): number;
+/** Format the slide number the way reveal.js does. */
+export declare function formatSlideNumber(format: true | "h.v" | "h/v" | "c" | "c/t", state: Position, columns: Column[], oneBased?: boolean): string;
+//#endregion
+export { navigation_d_exports };

package/dist/core/navigation.js

@@ -0,0 +1,244 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+//#region src/core/navigation.ts
+var navigation_exports = /* @__PURE__ */ __exportAll({
+	availableRoutes: () => availableRoutes,
+	clampPosition: () => clampPosition,
+	down: () => down,
+	first: () => first,
+	formatSlideNumber: () => formatSlideNumber,
+	goto: () => goto,
+	initialNav: () => initialNav,
+	key: () => key,
+	last: () => last,
+	left: () => left,
+	next: () => next,
+	nextClick: () => nextClick,
+	prev: () => prev,
+	prevClick: () => prevClick,
+	progressOf: () => progressOf,
+	right: () => right,
+	setTotal: () => setTotal,
+	up: () => up
+});
+const key = (h, v) => `${h},${v}`;
+function initialNav() {
+	return {
+		h: 0,
+		v: 0,
+		click: 0,
+		direction: "none",
+		overview: false,
+		paused: false,
+		autoSliding: false,
+		totals: {},
+		presenter: null,
+		follow: true,
+		seq: 0
+	};
+}
+function clampPosition(columns, p) {
+	const h = Math.min(Math.max(0, p.h ?? 0), Math.max(0, columns.length - 1));
+	const col = columns[h];
+	return {
+		h,
+		v: Math.min(Math.max(0, p.v ?? 0), Math.max(0, (col?.slides.length ?? 1) - 1)),
+		click: Math.max(0, p.click ?? 0)
+	};
+}
+function availableRoutes(state, columns, config) {
+	const col = columns[state.h];
+	const total = state.totals[key(state.h, state.v)] ?? 0;
+	const left = state.h > 0 || config.loop;
+	const right = state.h < columns.length - 1 || config.loop;
+	return {
+		left: config.rtl ? right : left,
+		right: config.rtl ? left : right,
+		up: state.v > 0,
+		down: !!col && state.v < col.slides.length - 1,
+		prevClick: state.click > 0,
+		nextClick: state.click < total
+	};
+}
+function step(state, next, direction, columns) {
+	const p = clampPosition(columns, {
+		...state,
+		...next
+	});
+	return {
+		...state,
+		...p,
+		direction,
+		seq: state.seq + 1
+	};
+}
+/** Move to an exact position (a hash, a link, the presenter). Clicks default to 0. */
+function goto(state, columns, to) {
+	const p = clampPosition(columns, {
+		h: to.h ?? state.h,
+		v: to.v ?? state.v,
+		click: to.click ?? 0
+	});
+	const direction = p.h > state.h ? "forward" : p.h < state.h ? "back" : p.v > state.v ? "down" : p.v < state.v ? "up" : "none";
+	return {
+		...state,
+		...p,
+		direction,
+		seq: state.seq + 1
+	};
+}
+function right(state, columns, config) {
+	const last = columns.length - 1;
+	if (state.h < last) {
+		const v = config.navigationMode === "grid" ? Math.min(state.v, columns[state.h + 1].slides.length - 1) : 0;
+		return step(state, {
+			h: state.h + 1,
+			v,
+			click: 0
+		}, "forward", columns);
+	}
+	if (config.loop) return step(state, {
+		h: 0,
+		v: 0,
+		click: 0
+	}, "forward", columns);
+	return state;
+}
+function left(state, columns, config) {
+	if (state.h > 0) {
+		const col = columns[state.h - 1];
+		const v = config.navigationMode === "grid" ? Math.min(state.v, col.slides.length - 1) : config.navigationMode === "linear" ? col.slides.length - 1 : 0;
+		return step(state, {
+			h: state.h - 1,
+			v,
+			click: 0
+		}, "back", columns);
+	}
+	if (config.loop) return step(state, {
+		h: columns.length - 1,
+		v: 0,
+		click: 0
+	}, "back", columns);
+	return state;
+}
+function down(state, columns) {
+	const col = columns[state.h];
+	if (col && state.v < col.slides.length - 1) return step(state, {
+		v: state.v + 1,
+		click: 0
+	}, "down", columns);
+	return state;
+}
+function up(state, columns) {
+	if (state.v > 0) return step(state, {
+		v: state.v - 1,
+		click: 0
+	}, "up", columns);
+	return state;
+}
+function nextClick(state) {
+	const total = state.totals[key(state.h, state.v)] ?? 0;
+	if (state.click < total) return {
+		...state,
+		click: state.click + 1,
+		direction: "forward",
+		seq: state.seq + 1
+	};
+	return state;
+}
+function prevClick(state) {
+	if (state.click > 0) return {
+		...state,
+		click: state.click - 1,
+		direction: "back",
+		seq: state.seq + 1
+	};
+	return state;
+}
+/**
+* `next`: the next click, else the slide beneath, else the next column. In linear mode the deck
+* reads like a book: every vertical slide is a page. Matches reveal.js's space bar.
+*/
+function next(state, columns, config) {
+	const clicked = nextClick(state);
+	if (clicked !== state) return clicked;
+	const routes = availableRoutes(state, columns, config);
+	if (routes.down) return down(state, columns);
+	if (config.rtl ? routes.left : routes.right) return config.rtl ? left(state, columns, config) : right(state, columns, config);
+	return state;
+}
+/** `prev`: the previous click, else the slide above, else the previous column. */
+function prev(state, columns, config, opts = {}) {
+	const unclicked = prevClick(state);
+	if (unclicked !== state) return unclicked;
+	const routes = availableRoutes(state, columns, config);
+	let moved = state;
+	if (routes.up) moved = up(state, columns);
+	else if (config.rtl ? routes.right : routes.left) moved = config.rtl ? right(state, columns, config) : left(state, columns, config);
+	if (moved === state) return state;
+	if (opts.toLastClick !== false) {
+		const total = moved.totals[key(moved.h, moved.v)] ?? 0;
+		return {
+			...moved,
+			click: total
+		};
+	}
+	return moved;
+}
+function first(state, columns) {
+	return step(state, {
+		h: 0,
+		v: 0,
+		click: 0
+	}, "back", columns);
+}
+function last(state, columns) {
+	const h = Math.max(0, columns.length - 1);
+	return step(state, {
+		h,
+		v: Math.max(0, (columns[h]?.slides.length ?? 1) - 1),
+		click: 0
+	}, "forward", columns);
+}
+/** Record the click total the runtime found for a slide; clamps the current click if needed. */
+function setTotal(state, h, v, total) {
+	const k = key(h, v);
+	if (state.totals[k] === total) return state;
+	const totals = {
+		...state.totals,
+		[k]: total
+	};
+	const click = h === state.h && v === state.v ? Math.min(state.click, total) : state.click;
+	return {
+		...state,
+		totals,
+		click
+	};
+}
+/** 0 at the first slide, 1 at the last. */
+function progressOf(state, columns) {
+	const total = columns.reduce((n, c) => n + c.slides.length, 0);
+	if (total <= 1) return 1;
+	let flat = 0;
+	for (let i = 0; i < state.h; i++) flat += columns[i].slides.length;
+	flat += state.v;
+	return flat / (total - 1);
+}
+/** Format the slide number the way reveal.js does. */
+function formatSlideNumber(format, state, columns, oneBased = true) {
+	const offset = oneBased ? 1 : 0;
+	const flat = (() => {
+		let n = 0;
+		for (let i = 0; i < state.h; i++) n += columns[i].slides.length;
+		return n + state.v + offset;
+	})();
+	const total = columns.reduce((n, c) => n + c.slides.length, 0);
+	const hasVertical = columns.some((c) => c.slides.length > 1);
+	switch (format) {
+		case "c": return String(flat);
+		case "c/t": return `${flat} / ${total}`;
+		case "h/v": return hasVertical && state.v > 0 ? `${state.h + offset} / ${state.v + offset}` : String(state.h + offset);
+		default: return hasVertical && state.v > 0 ? `${state.h + offset}.${state.v + offset}` : String(state.h + offset);
+	}
+}
+//#endregion
+export { availableRoutes, clampPosition, down, first, formatSlideNumber, goto, initialNav, key, last, left, navigation_exports, next, nextClick, prev, prevClick, progressOf, right, setTotal, up };

package/dist/core/poster.js

@@ -0,0 +1,30 @@
+//#region src/core/poster.ts
+/**
+* Posters stand in for an embedded page wherever it cannot be live: the print pages, the
+* overview tiles, the presenter's next-slide box, the scroll view — and behind the shield while
+* the real page loads. A deck names one (`poster: shots/map.jpg` on an iframe slide, or
+* `<Iframe poster>`); without one, `deck export` captures a screenshot of the URL at the pane's
+* size into `public/posters/` under a name both sides derive from the URL, so nothing else has
+* to be wired.
+*/
+const POSTER_DEFAULT_SIZE = [1600, 900];
+/** FNV-1a over the URL, in base 36: short, stable, filename-safe. */
+function posterHash(url) {
+	let h = 2166136261;
+	for (let i = 0; i < url.length; i++) {
+		h ^= url.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(36);
+}
+/** The path under `public/` where a captured poster for this URL at this pane size lives. */
+function posterName(url, width, height) {
+	return `posters/${posterHash(url)}@${Math.round(width)}x${Math.round(height)}.jpg`;
+}
+/** A poster path as written in a deck → a URL the page can load. */
+function resolvePoster(path, base) {
+	if (/^(https?:)?\/\//.test(path) || path.startsWith("data:") || path.startsWith("/")) return path;
+	return `${base.replace(/\/?$/, "/")}${path}`;
+}
+//#endregion
+export { POSTER_DEFAULT_SIZE, posterHash, posterName, resolvePoster };

package/dist/core/store.d.ts

@@ -0,0 +1,20 @@
+//#region src/core/store.d.ts
+/**
+ * A minimal external store: one value, subscribers, selectors through `useSyncExternalStore`.
+ * The deck keeps its navigation state here rather than in React state so the keyboard, the hash,
+ * the live room and the presenter window can all read and write it without a render in between.
+ */
+export interface Store<T> {
+  get(): T;
+  set(next: T): void;
+  update(fn: (prev: T) => T): void;
+  subscribe(listener: (value: T, prev: T) => void): () => void;
+}
+export declare function createStore<T>(initial: T): Store<T>;
+/**
+ * Read a slice of a store; re-renders only when the selected slice changes. Selectors may return
+ * fresh objects (`(s) => ({ h: s.h, v: s.v })`): the last result is kept and returned again while
+ * it is shallow-equal, which is what keeps `useSyncExternalStore` from looping.
+ */
+export declare function useStore<T, S = T>(store: Store<T>, selector?: (value: T) => S): S;
+//#endregion

package/dist/core/store.js

@@ -0,0 +1,64 @@
+import { useRef, useSyncExternalStore } from "react";
+//#region src/core/store.ts
+function createStore(initial) {
+	let value = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get: () => value,
+		set(next) {
+			if (Object.is(next, value)) return;
+			const prev = value;
+			value = next;
+			for (const l of listeners) l(value, prev);
+		},
+		update(fn) {
+			this.set(fn(value));
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+const identity = (v) => v;
+function shallowEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	for (const k of ka) if (!Object.is(a[k], b[k])) return false;
+	return true;
+}
+/**
+* Read a slice of a store; re-renders only when the selected slice changes. Selectors may return
+* fresh objects (`(s) => ({ h: s.h, v: s.v })`): the last result is kept and returned again while
+* it is shallow-equal, which is what keeps `useSyncExternalStore` from looping.
+*/
+function useStore(store, selector = identity) {
+	const last = useRef(null);
+	const snapshot = () => {
+		const input = store.get();
+		const cached = last.current;
+		if (cached && Object.is(cached.input, input)) return cached.output;
+		const output = selector(input);
+		if (cached && shallowEqual(cached.output, output)) {
+			last.current = {
+				input,
+				output: cached.output
+			};
+			return cached.output;
+		}
+		last.current = {
+			input,
+			output
+		};
+		return output;
+	};
+	return useSyncExternalStore((cb) => store.subscribe(() => cb()), snapshot, snapshot);
+}
+//#endregion
+export { createStore, useStore };

package/dist/core/touch.js

@@ -0,0 +1,27 @@
+//#region src/core/touch.ts
+function createSwipeTracker(threshold = 40, maxDuration = 800) {
+	let sx = 0;
+	let sy = 0;
+	let st = 0;
+	let active = false;
+	return {
+		start(x, y, t) {
+			sx = x;
+			sy = y;
+			st = t;
+			active = true;
+		},
+		end(x, y, t) {
+			if (!active) return null;
+			active = false;
+			if (t - st > maxDuration) return null;
+			const dx = x - sx;
+			const dy = y - sy;
+			if (Math.abs(dx) < threshold && Math.abs(dy) < threshold) return null;
+			if (Math.abs(dx) > Math.abs(dy)) return dx < 0 ? "left" : "right";
+			return dy < 0 ? "up" : "down";
+		}
+	};
+}
+//#endregion
+export { createSwipeTracker };