@heyramzi/ui 2.9.0 → 2.10.1

package/dist/slides/navigation.js

@@ -0,0 +1,89 @@
+export const visibleIndexes = (slides)=>slides.flatMap((slide, index)=>slide.hidden ? [] : [
+            index
+        ]);
+const clamp = (value, min, max)=>Math.min(max, Math.max(min, value));
+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)
+    };
+}
+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;
+}
+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
+    };
+}
+export function ordinalOf(slides, index) {
+    const visible = visibleIndexes(slides);
+    return {
+        n: Math.max(0, visible.indexOf(index)) + 1,
+        of: visible.length
+    };
+}
+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;
+}
+export function parseSlideParam(raw, total) {
+    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"
+};
+export function keyAction(key, shift = false) {
+    if (key === " ") return shift ? "prev" : "next";
+    return KEYS[key] ?? null;
+}

package/dist/slides/types.js

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

package/dist/status/define-statuses.js

@@ -0,0 +1,16 @@
+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
+    };
+}

package/dist/status/index.js

@@ -0,0 +1,4 @@
+export { default as StatusBadge } from "../../src/status/status-badge.svelte";
+export { default as StatusDot } from "../../src/status/status-dot.svelte";
+export { default as StatusIcon } from "../../src/status/status-icon.svelte";
+export { defineStatuses } from "./define-statuses.js";

package/dist/test-setup.js

@@ -0,0 +1,26 @@
+class ObserverStub {
+    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
+    });
+if (globalThis.SVGElement && !("getTotalLength" in globalThis.SVGElement.prototype)) {
+    Object.defineProperty(globalThis.SVGElement.prototype, "getTotalLength", {
+        value: ()=>100,
+        configurable: true
+    });
+}

package/dist/thread/index.js

@@ -0,0 +1,3 @@
+export { default as Thread } from "../../src/thread/thread.svelte";
+export { buildThread, fillCount, interleave, resolveThreadLabels, resolvedCount } from "./logic.js";
+export { DEFAULT_THREAD_LABELS } from "./types.js";

package/dist/thread/logic.js

@@ -0,0 +1,94 @@
+import { DEFAULT_THREAD_LABELS } from "./types.js";
+function at(iso) {
+    const ms = Date.parse(iso);
+    return Number.isNaN(ms) ? Number.POSITIVE_INFINITY : ms;
+}
+function time(comment) {
+    return at(comment.createdAt);
+}
+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);
+}
+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) ?? [])
+        }));
+}
+export function resolvedCount(nodes) {
+    return nodes.filter((node)=>node.comment.resolved).length;
+}
+export function resolveThreadLabels(overrides) {
+    return {
+        ...DEFAULT_THREAD_LABELS,
+        ...overrides
+    };
+}
+export function fillCount(label, count) {
+    return label.replaceAll("{count}", String(count));
+}
+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;
+}

package/dist/thread/types.js

@@ -0,0 +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"
+};

package/dist/work/board-order.js

@@ -0,0 +1,109 @@
+const DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const INT_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const ZERO = DIGITS.charAt(0);
+function integerLength(head) {
+    const i = INT_DIGITS.indexOf(head);
+    if (i === -1) throw new Error("invalid order key head: " + head);
+    const half = INT_DIGITS.length / 2;
+    return i < half ? half - i + 1 : i - half + 2;
+}
+function integerPart(key) {
+    const length = integerLength(key.charAt(0));
+    if (length > key.length) throw new Error("invalid order key: " + key);
+    return key.slice(0, length);
+}
+function smallestInteger() {
+    return INT_DIGITS.charAt(0) + ZERO.repeat(INT_DIGITS.length / 2);
+}
+function midpoint(a, b) {
+    if (b != null && a >= b) throw new Error(a + " >= " + b);
+    if (a.slice(-1) === ZERO || b && b.slice(-1) === ZERO) throw new Error("trailing zero");
+    if (b) {
+        let n = 0;
+        while((a[n] ?? ZERO) === b[n])n++;
+        if (n > 0) return b.slice(0, n) + midpoint(a.slice(n), b.slice(n));
+    }
+    const digitA = a ? DIGITS.indexOf(a.charAt(0)) : 0;
+    const digitB = b != null ? DIGITS.indexOf(b.charAt(0)) : DIGITS.length;
+    if (digitB - digitA > 1) {
+        return DIGITS.charAt(Math.round(0.5 * (digitA + digitB)));
+    }
+    if (b && b.length > 1) return b.slice(0, 1);
+    return DIGITS.charAt(digitA) + midpoint(a.slice(1), null);
+}
+function incrementInteger(x) {
+    const head = x.charAt(0);
+    let trailing = "";
+    for(let i = x.length - 1; i >= 1; i--){
+        const d = DIGITS.indexOf(x.charAt(i)) + 1;
+        if (d === DIGITS.length) trailing = ZERO + trailing;
+        else return head + x.slice(1, i) + DIGITS.charAt(d) + trailing;
+    }
+    const headIndex = INT_DIGITS.indexOf(head);
+    if (headIndex === INT_DIGITS.length - 1) return null;
+    const h = INT_DIGITS.charAt(headIndex + 1);
+    const delta = integerLength(h) - integerLength(head);
+    return h + (delta > 0 ? trailing + ZERO : delta < 0 ? trailing.slice(1) : trailing);
+}
+function decrementInteger(x) {
+    const head = x.charAt(0);
+    const last = DIGITS.charAt(DIGITS.length - 1);
+    let trailing = "";
+    for(let i = x.length - 1; i >= 1; i--){
+        const d = DIGITS.indexOf(x.charAt(i)) - 1;
+        if (d === -1) trailing = last + trailing;
+        else return head + x.slice(1, i) + DIGITS.charAt(d) + trailing;
+    }
+    const headIndex = INT_DIGITS.indexOf(head);
+    if (headIndex === 0) return null;
+    const h = INT_DIGITS.charAt(headIndex - 1);
+    const delta = integerLength(h) - integerLength(head);
+    return h + (delta > 0 ? trailing + last : delta < 0 ? trailing.slice(1) : trailing);
+}
+export function keyBetween(a, b) {
+    if (a != null && b != null && a > b) [a, b] = [
+        b,
+        a
+    ];
+    if (a == null) {
+        if (b == null) return INT_DIGITS.charAt(INT_DIGITS.length / 2) + ZERO;
+        const ib = integerPart(b);
+        const fb = b.slice(ib.length);
+        if (ib === smallestInteger()) return ib + midpoint("", fb);
+        if (ib < b) return ib;
+        const res = decrementInteger(ib);
+        if (res == null) throw new Error("cannot decrement any more");
+        return res;
+    }
+    if (b == null) {
+        const ia = integerPart(a);
+        const fa = a.slice(ia.length);
+        const i = incrementInteger(ia);
+        return i == null ? ia + midpoint(fa, null) : i;
+    }
+    const ia = integerPart(a);
+    const fa = a.slice(ia.length);
+    const ib = integerPart(b);
+    const fb = b.slice(ib.length);
+    if (ia === ib) return ia + midpoint(fa, fb);
+    const i = incrementInteger(ia);
+    if (i == null) throw new Error("cannot increment any more");
+    if (i < b) return i;
+    return ia + midpoint(fa, null);
+}
+export function boardOrderAt(column, index, order) {
+    let lower = null;
+    for (const item of column.slice(0, index)){
+        const key = order(item);
+        if (key != null && (lower === null || key > lower)) lower = key;
+    }
+    let upper = null;
+    for (const item of column.slice(index)){
+        const key = order(item);
+        if (key != null && (lower === null || key > lower)) {
+            upper = key;
+            break;
+        }
+    }
+    return keyBetween(lower, upper);
+}

package/dist/work/dates.js

@@ -0,0 +1,19 @@
+const DAY_MS = 86_400_000;
+export function dayNumber(iso) {
+    const [y = 1970, m = 1, d = 1] = iso.slice(0, 10).split("-").map(Number);
+    return Math.round(Date.UTC(y, m - 1, d) / DAY_MS);
+}
+export function isoFromDay(day) {
+    return new Date(day * DAY_MS).toISOString().slice(0, 10);
+}
+export function addDays(iso, days) {
+    return isoFromDay(dayNumber(iso) + days);
+}
+export function todayIso() {
+    const now = new Date();
+    const local = new Date(now.getTime() - now.getTimezoneOffset() * 60_000);
+    return local.toISOString().slice(0, 10);
+}
+export function weekday(day) {
+    return new Date(day * DAY_MS).getUTCDay();
+}

package/dist/work/detail/detail-types.js

@@ -0,0 +1,20 @@
+export const DEFAULT_TASK_DETAIL_LABELS = {
+    markComplete: "Mark complete",
+    markIncomplete: "Mark incomplete",
+    editTitle: "Edit title",
+    description: "Description",
+    addDescription: "Add a description",
+    editDescription: "Edit description",
+    save: "Save",
+    saving: "Saving",
+    cancel: "Cancel",
+    comments: "Activity",
+    commentPlaceholder: "Leave a comment",
+    commentSend: "Comment",
+    commentEdit: "Edit comment",
+    commentDelete: "Delete comment",
+    commentEdited: "edited",
+    commentsEmpty: "No comments yet",
+    ai: "AI",
+    properties: "Properties"
+};

package/dist/work/docs/edited.js

@@ -0,0 +1,39 @@
+export function parseStamp(value) {
+    if (value === null || value === undefined || value === "") return null;
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function yearOf(date, { locale = "en-US", timeZone }) {
+    return new Intl.DateTimeFormat(locale, {
+        year: "numeric",
+        timeZone
+    }).format(date);
+}
+export function shortDate(value, options = {}) {
+    const date = parseStamp(value);
+    if (!date) return "";
+    const { locale = "en-US", timeZone, now = new Date() } = options;
+    const sameYear = yearOf(date, options) === yearOf(now, options);
+    return new Intl.DateTimeFormat(locale, {
+        month: "short",
+        day: "numeric",
+        year: sameYear ? undefined : "numeric",
+        timeZone
+    }).format(date);
+}
+export function editStamp(value, options = {}) {
+    const date = parseStamp(value);
+    if (!date) return "";
+    const { locale = "en-US", timeZone } = options;
+    const time = new Intl.DateTimeFormat(locale, {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        timeZone
+    }).format(date);
+    return `${shortDate(date, options)}, ${time}`;
+}
+export function editedLabel(value, label = "Edited", options = {}) {
+    const day = shortDate(value, options);
+    return day ? `${label} ${day}` : label;
+}

package/dist/work/docs/index.js

@@ -0,0 +1,7 @@
+export { default as DocEditorPage } from "../../../src/work/docs/doc-editor-page.svelte";
+export { default as DocMenu } from "../../../src/work/docs/doc-menu.svelte";
+export { default as EditedChip } from "../../../src/work/docs/edited-chip.svelte";
+export { DEFAULT_DOC_LABELS, docLabels } from "./labels.js";
+export { anchorIds, headingsOf, outlineOf, outlineOfDoc, slugify } from "./outline.js";
+export { editStamp, editedLabel, parseStamp, shortDate } from "./edited.js";
+export { copyOptions, filterMenu, menuItems, shortcutLabel, shortcutTarget } from "./menu.js";

package/dist/work/docs/labels.js

@@ -0,0 +1,38 @@
+export const DEFAULT_DOC_LABELS = {
+    titlePlaceholder: "New document",
+    untitled: "Untitled",
+    edited: "Edited",
+    showAuthorNames: "Show author names",
+    ownedBy: "Owned by",
+    lastEditBy: "Last edit by",
+    showHistory: "Show document history",
+    menu: "Document actions",
+    filter: "Filter…",
+    noResults: "Nothing matches",
+    moveTo: "Move to",
+    duplicate: "Duplicate",
+    rename: "Rename",
+    template: "New template from document",
+    favorite: "Favorite",
+    unfavorite: "Remove from favorites",
+    copy: "Copy",
+    copyUrl: "Copy URL",
+    copyTitle: "Copy title",
+    copyTitleAsLink: "Copy title as link",
+    copyMarkdown: "Copy content as Markdown",
+    remind: "Remind me",
+    history: "Show document history",
+    delete: "Delete",
+    deleteTitle: (title)=>`Delete "${title}"`,
+    deleteDetail: "This can't be undone.",
+    cancel: "Cancel",
+    back: "Back",
+    outline: "Outline",
+    copyLink: "Copy link"
+};
+export function docLabels(partial) {
+    return {
+        ...DEFAULT_DOC_LABELS,
+        ...partial
+    };
+}

package/dist/work/docs/menu.js

@@ -0,0 +1,121 @@
+import { tiptapToMarkdown } from "../../editor/markdown.js";
+export const SHORTCUTS = {
+    move: {
+        key: "P",
+        shift: true
+    },
+    rename: {
+        key: "R",
+        shift: true
+    },
+    favorite: {
+        key: "F",
+        alt: true
+    },
+    remind: {
+        key: "H",
+        shift: true
+    }
+};
+export function shortcutLabel(shortcut) {
+    return `${shortcut.shift ? "⇧" : ""}${shortcut.alt ? "⌥" : ""}${shortcut.key.toUpperCase()}`;
+}
+export function menuItems(available, labels, options = {}) {
+    const all = [
+        {
+            id: "move",
+            label: labels.moveTo,
+            group: 0
+        },
+        {
+            id: "duplicate",
+            label: labels.duplicate,
+            group: 0
+        },
+        {
+            id: "rename",
+            label: labels.rename,
+            group: 0
+        },
+        {
+            id: "template",
+            label: labels.template,
+            group: 0
+        },
+        {
+            id: "favorite",
+            label: options.favorited ? labels.unfavorite : labels.favorite,
+            group: 1
+        },
+        {
+            id: "copy",
+            label: labels.copy,
+            submenu: true,
+            group: 1
+        },
+        {
+            id: "remind",
+            label: labels.remind,
+            group: 1
+        },
+        {
+            id: "history",
+            label: labels.history,
+            group: 2
+        },
+        {
+            id: "delete",
+            label: labels.delete,
+            danger: true,
+            group: 2
+        }
+    ];
+    return all.filter((item)=>available[item.id]).map((item)=>Object.assign(item, {
+            shortcut: SHORTCUTS[item.id]
+        }));
+}
+export function filterMenu(items, query) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) return items;
+    return items.filter((item)=>{
+        const label = item.label.toLowerCase();
+        return words.every((word)=>label.includes(word));
+    });
+}
+export function shortcutTarget(event, items) {
+    if (event.metaKey || event.ctrlKey) return null;
+    const hit = items.find((item)=>item.shortcut && event.code === `Key${item.shortcut.key.toUpperCase()}` && !!item.shortcut.shift === event.shiftKey && !!item.shortcut.alt === event.altKey);
+    return hit?.id ?? null;
+}
+export function copyOptions(source, labels) {
+    const title = source.title.trim() || labels.untitled;
+    const options = [];
+    if (source.url) options.push({
+        kind: "url",
+        label: labels.copyUrl,
+        text: source.url
+    });
+    options.push({
+        kind: "title",
+        label: labels.copyTitle,
+        text: title
+    });
+    if (source.url) {
+        options.push({
+            kind: "link",
+            label: labels.copyTitleAsLink,
+            text: `[${title.replace(/([[\]\\])/g, "\\$1")}](${source.url})`
+        });
+    }
+    if (source.content) {
+        options.push({
+            kind: "markdown",
+            label: labels.copyMarkdown,
+            text: tiptapToMarkdown(source.content)
+        });
+    }
+    return options;
+}
+export function deleteName(title, labels) {
+    return title.trim() || labels.untitled;
+}

package/dist/work/docs/outline.js

@@ -0,0 +1,39 @@
+import { anchorIds } from "../../editor/anchors.js";
+export { anchorIds, slugify } from "../../editor/anchors.js";
+function textOf(node) {
+    if (node.type === "text") return node.text ?? "";
+    return (node.content ?? []).map(textOf).join("");
+}
+export function headingsOf(doc) {
+    const found = [];
+    const walk = (node)=>{
+        if (node.type === "heading") {
+            const level = typeof node.attrs?.level === "number" ? node.attrs.level : 1;
+            found.push({
+                label: textOf(node).trim(),
+                level
+            });
+            return;
+        }
+        for (const child of node.content ?? [])walk(child);
+    };
+    if (doc && typeof doc === "object") walk(doc);
+    const ids = anchorIds(found.map((heading)=>heading.label));
+    return found.map((heading, i)=>({
+            id: ids[i],
+            label: heading.label,
+            level: heading.level
+        }));
+}
+export function outlineOf(headings) {
+    const items = headings.filter((heading)=>(heading.level === 2 || heading.level === 3) && heading.label !== "");
+    if (items.length < 2) return [];
+    return items.map(({ id, label, level })=>({
+            id,
+            label,
+            level
+        }));
+}
+export function outlineOfDoc(doc) {
+    return outlineOf(headingsOf(doc));
+}