@heyramzi/ui 2.11.1 → 2.11.2

package/dist/slides/navigation.js

@@ -1,89 +1,94 @@
-export const visibleIndexes = (slides)=>slides.flatMap((slide, index)=>slide.hidden ? [] : [
-            index
-        ]);
-const clamp = (value, min, max)=>Math.min(max, Math.max(min, value));
+export const visibleIndexes = (slides) => slides.flatMap((slide, index) => slide.hidden ? [] : [index]);
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+/** Snaps a position onto a visible slide and a real step. Empty decks stay at 0, 0. */
 export function settle(slides, position) {
-    const visible = visibleIndexes(slides);
-    if (visible.length === 0) return {
-        index: 0,
-        step: 0
-    };
-    const index = visible.find((i)=>i >= position.index) ?? visible[visible.length - 1];
-    return {
-        index,
-        step: clamp(position.step, 0, slides[index].steps)
-    };
+	const visible = visibleIndexes(slides);
+	if (visible.length === 0) return {
+		index: 0,
+		step: 0
+	};
+	const index = visible.find((i) => i >= position.index) ?? visible[visible.length - 1];
+	return {
+		index,
+		step: clamp(position.step, 0, slides[index].steps)
+	};
 }
+/** The position after one forward press, or null at the end of a deck that doesn't loop. */
 export function nextPosition(slides, from, loop = false) {
-    const visible = visibleIndexes(slides);
-    if (visible.length === 0) return null;
-    if (from.step < slides[from.index].steps) return {
-        index: from.index,
-        step: from.step + 1
-    };
-    const next = visible.find((i)=>i > from.index);
-    if (next !== undefined) return {
-        index: next,
-        step: 0
-    };
-    return loop ? {
-        index: visible[0],
-        step: 0
-    } : null;
+	const visible = visibleIndexes(slides);
+	if (visible.length === 0) return null;
+	if (from.step < slides[from.index].steps) return {
+		index: from.index,
+		step: from.step + 1
+	};
+	const next = visible.find((i) => i > from.index);
+	if (next !== undefined) return {
+		index: next,
+		step: 0
+	};
+	return loop ? {
+		index: visible[0],
+		step: 0
+	} : null;
 }
+/** The position after one back press. Landing on an earlier slide shows it fully revealed. */
 export function prevPosition(slides, from, loop = false) {
-    const visible = visibleIndexes(slides);
-    if (visible.length === 0) return null;
-    if (from.step > 0) return {
-        index: from.index,
-        step: from.step - 1
-    };
-    const before = visible.filter((i)=>i < from.index);
-    const index = before.length ? before[before.length - 1] : loop ? visible[visible.length - 1] : undefined;
-    return index === undefined ? null : {
-        index,
-        step: slides[index].steps
-    };
+	const visible = visibleIndexes(slides);
+	if (visible.length === 0) return null;
+	if (from.step > 0) return {
+		index: from.index,
+		step: from.step - 1
+	};
+	const before = visible.filter((i) => i < from.index);
+	const index = before.length ? before[before.length - 1] : loop ? visible[visible.length - 1] : undefined;
+	return index === undefined ? null : {
+		index,
+		step: slides[index].steps
+	};
 }
+/** Where slide `index` sits among the visible ones, 1 based, for "3 of 12". */
 export function ordinalOf(slides, index) {
-    const visible = visibleIndexes(slides);
-    return {
-        n: Math.max(0, visible.indexOf(index)) + 1,
-        of: visible.length
-    };
+	const visible = visibleIndexes(slides);
+	return {
+		n: Math.max(0, visible.indexOf(index)) + 1,
+		of: visible.length
+	};
 }
+/** How far through the deck a position is, 0 to 1. A slide's fragments split its own share. */
 export function progressOf(slides, position) {
-    const visible = visibleIndexes(slides);
-    if (visible.length === 0) return 0;
-    const at = Math.max(0, visible.indexOf(position.index));
-    const steps = slides[position.index]?.steps ?? 0;
-    const share = steps > 0 ? (position.step + 1) / (steps + 1) : 1;
-    return (at + share) / visible.length;
+	const visible = visibleIndexes(slides);
+	if (visible.length === 0) return 0;
+	const at = Math.max(0, visible.indexOf(position.index));
+	const steps = slides[position.index]?.steps ?? 0;
+	const share = steps > 0 ? (position.step + 1) / (steps + 1) : 1;
+	return (at + share) / visible.length;
 }
+/** Reads `?s=` as a zero based index. Anything that isn't a whole number in range is null. */
 export function parseSlideParam(raw, total) {
-    if (!raw || !/^\d+$/.test(raw)) return null;
-    const index = Number(raw) - 1;
-    return index >= 0 && index < total ? index : null;
+	if (!raw || !/^\d+$/.test(raw)) return null;
+	const index = Number(raw) - 1;
+	return index >= 0 && index < total ? index : null;
 }
 const KEYS = {
-    ArrowRight: "next",
-    PageDown: "next",
-    ArrowLeft: "prev",
-    PageUp: "prev",
-    ArrowUp: "up",
-    ArrowDown: "down",
-    Home: "first",
-    End: "last",
-    Enter: "select",
-    Escape: "close",
-    o: "overview",
-    O: "overview",
-    f: "fullscreen",
-    F: "fullscreen",
-    p: "presenter",
-    P: "presenter"
+	ArrowRight: "next",
+	PageDown: "next",
+	ArrowLeft: "prev",
+	PageUp: "prev",
+	ArrowUp: "up",
+	ArrowDown: "down",
+	Home: "first",
+	End: "last",
+	Enter: "select",
+	Escape: "close",
+	o: "overview",
+	O: "overview",
+	f: "fullscreen",
+	F: "fullscreen",
+	p: "presenter",
+	P: "presenter"
 };
+/** Maps a key to what the deck does with it. Space moves forward, Shift+Space back. */
 export function keyAction(key, shift = false) {
-    if (key === " ") return shift ? "prev" : "next";
-    return KEYS[key] ?? null;
+	if (key === " ") return shift ? "prev" : "next";
+	return KEYS[key] ?? null;
 }

package/dist/slides/types.js

@@ -1,6 +1,6 @@
 export const DECK_KEY = Symbol("heyramzi.deck");
 export const SLIDE_KEY = Symbol("heyramzi.slide");
 export const DEFAULT_CANVAS = {
-    w: 960,
-    h: 540
+	w: 960,
+	h: 540
 };

package/dist/status/define-statuses.js

@@ -1,16 +1,20 @@
+/**
+* Builds a status registry from a map, keeping its keys as a union so lookups stay typed:
+* `defineStatuses({ draft: { label: "Draft", tone: "neutral" } })`.
+*/
 export function defineStatuses(map) {
-    const lookup = map;
-    const find = (id)=>lookup[id];
-    return {
-        map,
-        ids: Object.keys(map),
-        has: (id)=>find(id) !== undefined,
-        get: find,
-        label: (id)=>find(id)?.label ?? id,
-        tone: (id)=>find(id)?.tone ?? "neutral",
-        icon: (id)=>find(id)?.icon,
-        variant: (id)=>find(id)?.variant ?? "open",
-        progress: (id)=>find(id)?.progress,
-        color: (id)=>find(id)?.color
-    };
+	const lookup = map;
+	const find = (id) => lookup[id];
+	return {
+		map,
+		ids: Object.keys(map),
+		has: (id) => find(id) !== undefined,
+		get: find,
+		label: (id) => find(id)?.label ?? id,
+		tone: (id) => find(id)?.tone ?? "neutral",
+		icon: (id) => find(id)?.icon,
+		variant: (id) => find(id)?.variant ?? "open",
+		progress: (id) => find(id)?.progress,
+		color: (id) => find(id)?.color
+	};
 }

package/dist/status/status-types.js

@@ -0,0 +1 @@
+export {};

package/dist/test-setup.js

@@ -1,26 +1,30 @@
+// WHY a setup file and not a beforeAll: layerchart and svelte/motion call
+// matchMedia while their module evaluates, which happens on import, before any hook runs. jsdom ships none of these, and bits-ui and embla measure with them.
 class ObserverStub {
-    observe() {}
-    unobserve() {}
-    disconnect() {}
-    takeRecords() {
-        return [];
-    }
+	observe() {}
+	unobserve() {}
+	disconnect() {}
+	takeRecords() {
+		return [];
+	}
 }
 globalThis.ResizeObserver ??= ObserverStub;
 globalThis.IntersectionObserver ??= ObserverStub;
-globalThis.matchMedia ??= (query)=>({
-        matches: false,
-        media: query,
-        onchange: null,
-        addEventListener () {},
-        removeEventListener () {},
-        addListener () {},
-        removeListener () {},
-        dispatchEvent: ()=>false
-    });
+globalThis.matchMedia ??= ((query) => ({
+	matches: false,
+	media: query,
+	onchange: null,
+	addEventListener() {},
+	removeEventListener() {},
+	addListener() {},
+	removeListener() {},
+	dispatchEvent: () => false
+}));
+// jsdom lays out nothing, so an SVG path has no length to give. The success
+// check reads one to set its dash offset.
 if (globalThis.SVGElement && !("getTotalLength" in globalThis.SVGElement.prototype)) {
-    Object.defineProperty(globalThis.SVGElement.prototype, "getTotalLength", {
-        value: ()=>100,
-        configurable: true
-    });
+	Object.defineProperty(globalThis.SVGElement.prototype, "getTotalLength", {
+		value: () => 100,
+		configurable: true
+	});
 }

package/dist/thread/logic.js

@@ -1,94 +1,90 @@
 import { DEFAULT_THREAD_LABELS } from "./types.js";
+/** A timestamp as a number, a malformed one last. */
 function at(iso) {
-    const ms = Date.parse(iso);
-    return Number.isNaN(ms) ? Number.POSITIVE_INFINITY : ms;
+	const ms = Date.parse(iso);
+	return Number.isNaN(ms) ? Number.POSITIVE_INFINITY : ms;
 }
 function time(comment) {
-    return at(comment.createdAt);
+	return at(comment.createdAt);
 }
+/** Oldest first, a malformed timestamp last, ties in the order they came. */
 function byTime(comments) {
-    return comments.map((comment, index)=>({
-            comment,
-            index
-        })).toSorted((a, b)=>time(a.comment) - time(b.comment) || a.index - b.index).map((row)=>row.comment);
+	return comments.map((comment, index) => ({
+		comment,
+		index
+	})).toSorted((a, b) => time(a.comment) - time(b.comment) || a.index - b.index).map((row) => row.comment);
 }
+/**
+* Roots in time order with their replies: a reply to a reply joins the root, an orphan becomes a
+* root, and a parent loop can't hang the walk.
+*/
 export function buildThread(comments) {
-    const byId = new Map(comments.map((comment)=>[
-            comment.id,
-            comment
-        ]));
-    function rootOf(comment) {
-        const seen = new Set([
-            comment.id
-        ]);
-        let current = comment;
-        for(;;){
-            const parent = current.parentId ? byId.get(current.parentId) : undefined;
-            if (!parent) return current;
-            if (seen.has(parent.id)) return comment;
-            seen.add(parent.id);
-            current = parent;
-        }
-    }
-    const replies = new Map();
-    const roots = [];
-    for (const comment of comments){
-        const root = rootOf(comment);
-        if (root.id === comment.id) roots.push(comment);
-        else replies.set(root.id, [
-            ...replies.get(root.id) ?? [],
-            comment
-        ]);
-    }
-    return byTime(roots).map((comment)=>({
-            comment,
-            replies: byTime(replies.get(comment.id) ?? [])
-        }));
+	const byId = new Map(comments.map((comment) => [comment.id, comment]));
+	function rootOf(comment) {
+		const seen = new Set([comment.id]);
+		let current = comment;
+		for (;;) {
+			const parent = current.parentId ? byId.get(current.parentId) : undefined;
+			if (!parent) return current;
+			if (seen.has(parent.id)) return comment;
+			seen.add(parent.id);
+			current = parent;
+		}
+	}
+	const replies = new Map();
+	const roots = [];
+	for (const comment of comments) {
+		const root = rootOf(comment);
+		if (root.id === comment.id) roots.push(comment);
+		else replies.set(root.id, [...replies.get(root.id) ?? [], comment]);
+	}
+	return byTime(roots).map((comment) => ({
+		comment,
+		replies: byTime(replies.get(comment.id) ?? [])
+	}));
 }
+/** How many conversations are resolved. */
 export function resolvedCount(nodes) {
-    return nodes.filter((node)=>node.comment.resolved).length;
+	return nodes.filter((node) => node.comment.resolved).length;
 }
 export function resolveThreadLabels(overrides) {
-    return {
-        ...DEFAULT_THREAD_LABELS,
-        ...overrides
-    };
+	return {
+		...DEFAULT_THREAD_LABELS,
+		...overrides
+	};
 }
+/** Fills `{count}` in a label, so a French host writes its own sentence. */
 export function fillCount(label, count) {
-    return label.replaceAll("{count}", String(count));
+	return label.replaceAll("{count}", String(count));
 }
+/** Conversations and events in time order, each run of events between two conversations as one item. */
 export function interleave(nodes, events) {
-    const timed = [
-        ...nodes.map((node, index)=>({
-                at: at(node.comment.createdAt),
-                index,
-                node
-            })),
-        ...events.map((event, index)=>({
-                at: at(event.at),
-                index: nodes.length + index,
-                event
-            }))
-    ].toSorted((a, b)=>a.at - b.at || a.index - b.index);
-    const items = [];
-    for (const row of timed){
-        if ("node" in row) {
-            items.push({
-                type: "node",
-                key: row.node.comment.id,
-                node: row.node
-            });
-            continue;
-        }
-        const last = items.at(-1);
-        if (last?.type === "events") last.events.push(row.event);
-        else items.push({
-            type: "events",
-            key: row.event.id,
-            events: [
-                row.event
-            ]
-        });
-    }
-    return items;
+	const timed = [...nodes.map((node, index) => ({
+		at: at(node.comment.createdAt),
+		index,
+		node
+	})), ...events.map((event, index) => ({
+		at: at(event.at),
+		index: nodes.length + index,
+		event
+	}))].toSorted((a, b) => a.at - b.at || a.index - b.index);
+	const items = [];
+	for (const row of timed) {
+		if ("node" in row) {
+			items.push({
+				type: "node",
+				key: row.node.comment.id,
+				node: row.node
+			});
+			continue;
+		}
+		const last = items.at(-1);
+		if (last?.type === "events") last.events.push(row.event);
+		else items.push({
+			type: "events",
+			key: row.event.id,
+			events: [row.event]
+		});
+	}
+	return items;
 }

package/dist/thread/types.js

@@ -1,23 +1,23 @@
 export const DEFAULT_THREAD_LABELS = {
-    title: "Activity",
-    empty: "No comments yet",
-    placeholder: "Leave a comment",
-    replyPlaceholder: "Reply",
-    send: "Comment",
-    sending: "Sending",
-    reply: "Reply",
-    edit: "Edit comment",
-    delete: "Delete comment",
-    edited: "edited",
-    save: "Save",
-    cancel: "Cancel",
-    resolve: "Resolve",
-    unresolve: "Reopen",
-    resolved: "Resolved",
-    showResolved: "Show {count} resolved",
-    hideResolved: "Hide resolved",
-    agent: "AI",
-    pinned: "Pinned",
-    showMore: "Show more",
-    showLess: "Show less"
+	title: "Activity",
+	empty: "No comments yet",
+	placeholder: "Leave a comment",
+	replyPlaceholder: "Reply",
+	send: "Comment",
+	sending: "Sending",
+	reply: "Reply",
+	edit: "Edit comment",
+	delete: "Delete comment",
+	edited: "edited",
+	save: "Save",
+	cancel: "Cancel",
+	resolve: "Resolve",
+	unresolve: "Reopen",
+	resolved: "Resolved",
+	showResolved: "Show {count} resolved",
+	hideResolved: "Hide resolved",
+	agent: "AI",
+	pinned: "Pinned",
+	showMore: "Show more",
+	showLess: "Show less"
 };