terminoir 0.7.0 → 0.9.0

package/dist/utils/expression.js

@@ -0,0 +1,116 @@
+/**
+ * Typed expression trees for a block editor. The op catalogue (e.g. Oyster's
+ * `GET /expressions/ops`) says what each op returns and what its slots accept; the editor only
+ * offers ops whose result fits the slot, so users cannot build an ill-typed tree.
+ */
+/** A slot of `kind` accepts an op returning `returns` (`value` is the wildcard both ways, `ids` only fits `ids`). */
+export function fits(kind, returns) {
+    if (kind === 'ids' || returns === 'ids')
+        return kind === returns;
+    return kind === 'value' || returns === 'value' || kind === returns;
+}
+export function opsFor(kind, ops) {
+    return ops.filter((op) => fits(kind, op.returns));
+}
+/** A fresh node for an op: empty single slots, one empty entry in list slots, blank params. */
+export function emptyNode(op) {
+    const node = { op: op.op };
+    for (const slot of op.slots)
+        node[slot.name] = slot.many ? [] : null;
+    for (const param of op.params)
+        node[param] = param === 'options' ? [] : '';
+    return node;
+}
+/** Text typed into a param, as the value it stands for (numbers and true/false become typed). */
+export function parseParam(param, text) {
+    if (param === 'options')
+        return text.split(',').map((s) => s.trim()).filter(Boolean);
+    const trimmed = text.trim();
+    if (param === 'key')
+        return trimmed;
+    if (trimmed === 'true' || trimmed === 'false')
+        return trimmed === 'true';
+    if (trimmed !== '' && !Number.isNaN(Number(trimmed)))
+        return Number(trimmed);
+    return text;
+}
+export function paramText(value) {
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value == null ? '' : String(value);
+}
+/** True when every slot is filled and every key param names a field. */
+export function isComplete(node, ops) {
+    if (!node || typeof node !== 'object')
+        return false;
+    const n = node;
+    const spec = ops.find((o) => o.op === n.op);
+    if (!spec)
+        return false;
+    if (spec.params.includes('key') && !n.key)
+        return false;
+    return spec.slots.every((slot) => {
+        const value = n[slot.name];
+        if (slot.many)
+            return Array.isArray(value) && value.length > 0 && value.every((v) => isComplete(v, ops));
+        return isComplete(value, ops);
+    });
+}
+/** Plain-English reading of a tree, built from op labels and slot names (no per-op templates). */
+export function describe(node, ops, fields = []) {
+    if (!node || typeof node !== 'object')
+        return '…';
+    const n = node;
+    const spec = ops.find((o) => o.op === n.op);
+    if (!spec)
+        return n.op;
+    const label = spec.label.toLowerCase();
+    if ('key' in n && spec.params.includes('key')) {
+        const field = fields.find((f) => f.key === n.key);
+        const name = field?.label ?? (n.key ? String(n.key) : '…');
+        return spec.slots.length ? `${label} ${name}` : spec.op === 'field' ? name : `${label} ${name}`;
+    }
+    if (spec.params.includes('value') && !spec.slots.length)
+        return JSON.stringify(n.value ?? '');
+    const part = (v) => describe(v, ops, fields);
+    const names = spec.slots.map((s) => s.name);
+    if (names.length === 2 && names[0] === 'left')
+        return `${part(n.left)} ${label} ${part(n.right)}`;
+    const many = spec.slots.find((s) => s.many);
+    if (many) {
+        const items = (Array.isArray(n[many.name]) ? n[many.name] : []).map(part);
+        return items.length > 1 ? `(${items.join(` ${label} `)})` : (items[0] ?? '…');
+    }
+    const pieces = spec.slots.map((s) => part(n[s.name]));
+    const options = spec.params.includes('options') ? ` ${paramText(n.options)}` : '';
+    if (!pieces.length)
+        return label;
+    if (pieces.length > 1)
+        return `${label} ${pieces.join(', ')}`;
+    // "is empty", "is one of" read after their argument; "not", "days until" before it.
+    return label.startsWith('is ') ? `${pieces[0]} ${label}${options}` : `${label} ${pieces[0]}`;
+}
+/** A copy of `root` with the value at `path` replaced (`undefined` removes a list entry). */
+export function setAt(root, path, value) {
+    if (!path.length)
+        return value;
+    const [head, ...rest] = path;
+    if (Array.isArray(root)) {
+        const next = root.slice();
+        const index = Number(head);
+        if (!rest.length && value === undefined)
+            next.splice(index, 1);
+        else
+            next[index] = setAt(root[index], rest, value);
+        return next;
+    }
+    const obj = (root && typeof root === 'object' ? root : {});
+    return { ...obj, [head]: setAt(obj[head], rest, value) };
+}
+/** Ops grouped by their `group`, in first-seen order, for an `<optgroup>` picker. */
+export function groupOps(ops) {
+    const groups = new Map();
+    for (const op of ops)
+        groups.set(op.group, [...(groups.get(op.group) ?? []), op]);
+    return [...groups].map(([group, list]) => ({ group, ops: list }));
+}

package/dist/utils/layout.d.ts

@@ -0,0 +1,15 @@
+/** Reading-order grid layout helpers: drag to reorder, drag an edge to change column span. */
+export type GridItem = {
+    id: string;
+    span: number;
+};
+export declare function moveTo<T extends {
+    id: string;
+}>(items: T[], id: string, index: number): T[];
+/** Index of the item whose centre is nearest to a point (ties keep the earlier one). */
+export declare function nearestIndex(centres: {
+    x: number;
+    y: number;
+}[], x: number, y: number): number;
+/** Column span after dragging an edge by `dx` pixels, snapped to whole columns and clamped. */
+export declare function spanAfterDrag(span: number, dx: number, columnWidth: number, min: number, max: number): number;

package/dist/utils/layout.js

@@ -0,0 +1,27 @@
+/** Reading-order grid layout helpers: drag to reorder, drag an edge to change column span. */
+export function moveTo(items, id, index) {
+    const from = items.findIndex((i) => i.id === id);
+    if (from < 0)
+        return items;
+    const next = items.slice();
+    const [item] = next.splice(from, 1);
+    next.splice(Math.max(0, Math.min(index, next.length)), 0, item);
+    return next;
+}
+/** Index of the item whose centre is nearest to a point (ties keep the earlier one). */
+export function nearestIndex(centres, x, y) {
+    let best = 0;
+    let bestDistance = Infinity;
+    centres.forEach((c, i) => {
+        const distance = (c.x - x) ** 2 + (c.y - y) ** 2;
+        if (distance < bestDistance)
+            [best, bestDistance] = [i, distance];
+    });
+    return best;
+}
+/** Column span after dragging an edge by `dx` pixels, snapped to whole columns and clamped. */
+export function spanAfterDrag(span, dx, columnWidth, min, max) {
+    if (columnWidth <= 0)
+        return span;
+    return Math.max(min, Math.min(max, span + Math.round(dx / columnWidth)));
+}

package/dist/utils/markdownEditor/blocks.d.ts

@@ -0,0 +1,27 @@
+/** Block types offered by the `/` menu, task-list checkboxes, and markdown output tidying. */
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Node } from '@milkdown/kit/prose/model';
+import { type EditorView } from '@milkdown/kit/prose/view';
+export type BlockItem = {
+    id: string;
+    label: string;
+    icon: string;
+    /** Extra words the `/` query matches, e.g. "h1" or "todo". */
+    keywords: string;
+    run: (ctx: Ctx) => void;
+};
+export declare const BLOCK_ITEMS: BlockItem[];
+export declare function matchBlocks(query: string): BlockItem[];
+/** List items with a `checked` attribute (task lists) get a real checkbox. */
+export declare const taskListItemView: import("@milkdown/kit/utils").$View<import("@milkdown/kit/utils").$Node, (initial: Node, view: EditorView, getPos: () => number | undefined) => {
+    dom: HTMLLIElement;
+    contentDOM: HTMLDivElement;
+    update(next: Node): boolean;
+    ignoreMutation: (mutation: {
+        target: globalThis.Node;
+    }) => boolean;
+}>;
+/** Hint text on an empty document. */
+export declare function placeholderPlugin(text: string): import("@milkdown/kit/utils").$Prose;
+/** Milkdown writes empty paragraphs as `<br />`; plain blank lines read better everywhere else. */
+export declare function tidyMarkdown(markdown: string): string;

package/dist/utils/markdownEditor/blocks.js

@@ -0,0 +1,107 @@
+import { editorViewCtx } from '@milkdown/kit/core';
+import { createCodeBlockCommand, insertHrCommand, listItemSchema, turnIntoTextCommand, wrapInBlockquoteCommand, wrapInBulletListCommand, wrapInHeadingCommand, wrapInOrderedListCommand } from '@milkdown/kit/preset/commonmark';
+import { Plugin } from '@milkdown/kit/prose/state';
+import { Decoration, DecorationSet } from '@milkdown/kit/prose/view';
+import { $prose, $view, callCommand } from '@milkdown/kit/utils';
+function markNearestListItemAsTask(ctx) {
+    const view = ctx.get(editorViewCtx);
+    const { $from } = view.state.selection;
+    for (let depth = $from.depth; depth > 0; depth--) {
+        const node = $from.node(depth);
+        if (node.type.name === 'list_item') {
+            view.dispatch(view.state.tr.setNodeMarkup($from.before(depth), undefined, { ...node.attrs, checked: false }));
+            return;
+        }
+    }
+}
+export const BLOCK_ITEMS = [
+    { id: 'text', label: 'Text', icon: 'paragraph', keywords: 'paragraph plain', run: (ctx) => callCommand(turnIntoTextCommand.key)(ctx) },
+    { id: 'h1', label: 'Heading 1', icon: 'heading', keywords: 'h1 title', run: (ctx) => callCommand(wrapInHeadingCommand.key, 1)(ctx) },
+    { id: 'h2', label: 'Heading 2', icon: 'heading', keywords: 'h2 subtitle', run: (ctx) => callCommand(wrapInHeadingCommand.key, 2)(ctx) },
+    { id: 'h3', label: 'Heading 3', icon: 'heading', keywords: 'h3', run: (ctx) => callCommand(wrapInHeadingCommand.key, 3)(ctx) },
+    {
+        id: 'todo',
+        label: 'Checklist',
+        icon: 'square-check',
+        keywords: 'todo task checkbox',
+        run: (ctx) => {
+            callCommand(wrapInBulletListCommand.key)(ctx);
+            markNearestListItemAsTask(ctx);
+        }
+    },
+    { id: 'bullet', label: 'Bulleted list', icon: 'list-ul', keywords: 'ul unordered', run: (ctx) => callCommand(wrapInBulletListCommand.key)(ctx) },
+    { id: 'number', label: 'Numbered list', icon: 'list-ol', keywords: 'ol ordered', run: (ctx) => callCommand(wrapInOrderedListCommand.key)(ctx) },
+    { id: 'quote', label: 'Quote', icon: 'quote-left', keywords: 'blockquote', run: (ctx) => callCommand(wrapInBlockquoteCommand.key)(ctx) },
+    { id: 'code', label: 'Code', icon: 'code', keywords: 'codeblock pre', run: (ctx) => callCommand(createCodeBlockCommand.key)(ctx) },
+    { id: 'divider', label: 'Divider', icon: 'minus', keywords: 'hr rule separator', run: (ctx) => callCommand(insertHrCommand.key)(ctx) }
+];
+export function matchBlocks(query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return BLOCK_ITEMS;
+    return BLOCK_ITEMS.filter((item) => `${item.label} ${item.keywords}`.toLowerCase().includes(q));
+}
+/** List items with a `checked` attribute (task lists) get a real checkbox. */
+export const taskListItemView = $view(listItemSchema.node, () => (initial, view, getPos) => {
+    let node = initial;
+    const dom = document.createElement('li');
+    const box = document.createElement('input');
+    box.type = 'checkbox';
+    box.contentEditable = 'false';
+    box.className = 'terminoir-md-task-box';
+    box.addEventListener('mousedown', (event) => event.preventDefault());
+    box.addEventListener('click', () => {
+        const pos = getPos();
+        if (pos === undefined)
+            return;
+        view.dispatch(view.state.tr.setNodeMarkup(pos, undefined, { ...node.attrs, checked: !node.attrs.checked }));
+    });
+    const contentDOM = document.createElement('div');
+    contentDOM.className = 'terminoir-md-task-body';
+    function render() {
+        const isTask = node.attrs.checked != null;
+        dom.dataset.itemType = isTask ? 'task' : '';
+        dom.dataset.checked = String(Boolean(node.attrs.checked));
+        box.checked = Boolean(node.attrs.checked);
+        box.hidden = !isTask;
+    }
+    dom.append(box, contentDOM);
+    render();
+    return {
+        dom,
+        contentDOM,
+        update(next) {
+            if (next.type !== node.type)
+                return false;
+            node = next;
+            render();
+            return true;
+        },
+        ignoreMutation: (mutation) => mutation.target === box
+    };
+});
+/** Hint text on an empty document. */
+export function placeholderPlugin(text) {
+    return $prose(() => new Plugin({
+        props: {
+            decorations(state) {
+                const { doc } = state;
+                const only = doc.firstChild;
+                if (doc.childCount !== 1 || !only?.isTextblock || only.content.size)
+                    return null;
+                return DecorationSet.create(doc, [
+                    Decoration.node(0, only.nodeSize, { class: 'terminoir-md--empty', 'data-placeholder': text })
+                ]);
+            }
+        }
+    }));
+}
+/** Milkdown writes empty paragraphs as `<br />`; plain blank lines read better everywhere else. */
+export function tidyMarkdown(markdown) {
+    return markdown
+        .split('\n')
+        .filter((line) => line.trim() !== '<br />')
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trimEnd();
+}

package/dist/utils/markdownEditor/triggers.d.ts

@@ -0,0 +1,17 @@
+export type TriggerKind = 'slash' | 'link';
+export type Trigger = {
+    kind: TriggerKind;
+    query: string;
+    /** Document range of the trigger text (`/qu` or `[[qu`), replaced when an item is chosen. */
+    from: number;
+    to: number;
+    /** Viewport position under the trigger, for the menu. */
+    left: number;
+    top: number;
+};
+export type TriggerHandlers = {
+    onchange: (trigger: Trigger | null) => void;
+    /** Return true when the open menu used the key. */
+    onkey: (key: string) => boolean;
+};
+export declare function triggerPlugin(handlers: TriggerHandlers, linksEnabled: boolean): import("@milkdown/kit/utils").$Prose;

package/dist/utils/markdownEditor/triggers.js

@@ -0,0 +1,69 @@
+/**
+ * Watches the text before the caret for a menu trigger (`/` at a word start, or `[[`) and
+ * hands arrow/Enter/Tab/Escape to the open menu while focus stays in the editor.
+ */
+import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
+import { $prose } from '@milkdown/kit/utils';
+const SLASH = /(?:^|\s)\/([\w-]{0,24})$/;
+const LINK = /\[\[([^[\]\n]{0,60})$/;
+const MENU_KEYS = new Set(['ArrowDown', 'ArrowUp', 'Enter', 'Tab', 'Escape']);
+const ATOM = '';
+function triggerAt(state, linksEnabled) {
+    const { selection } = state;
+    if (!selection.empty)
+        return null;
+    const { $from } = selection;
+    if (!$from.parent.isTextblock || $from.parent.type.spec.code)
+        return null;
+    const before = $from.parent.textBetween(0, $from.parentOffset, undefined, ATOM);
+    const link = linksEnabled ? LINK.exec(before) : null;
+    if (link)
+        return { kind: 'link', query: link[1], from: $from.pos - link[0].length, to: $from.pos };
+    const slash = SLASH.exec(before);
+    if (slash)
+        return { kind: 'slash', query: slash[1], from: $from.pos - slash[1].length - 1, to: $from.pos };
+    return null;
+}
+export function triggerPlugin(handlers, linksEnabled) {
+    const key = new PluginKey('terminoirTriggers');
+    /** A trigger closed with Escape stays closed until the caret leaves it. */
+    let dismissedFrom = null;
+    let open = false;
+    function report(view) {
+        const found = view.hasFocus() ? triggerAt(view.state, linksEnabled) : null;
+        if (!found || found.from === dismissedFrom) {
+            if (!found)
+                dismissedFrom = null;
+            if (open)
+                handlers.onchange(null);
+            open = false;
+            return;
+        }
+        const coords = view.coordsAtPos(found.from);
+        open = true;
+        handlers.onchange({ ...found, left: coords.left, top: coords.bottom });
+    }
+    return $prose(() => new Plugin({
+        key,
+        view: () => ({ update: report }),
+        props: {
+            handleKeyDown(view, event) {
+                if (!open || !MENU_KEYS.has(event.key))
+                    return false;
+                if (event.key === 'Escape') {
+                    dismissedFrom = triggerAt(view.state, linksEnabled)?.from ?? null;
+                    report(view);
+                    return true;
+                }
+                return handlers.onkey(event.key);
+            },
+            handleDOMEvents: {
+                blur(view) {
+                    // Let a click on a menu item land before the menu disappears.
+                    setTimeout(() => report(view), 150);
+                    return false;
+                }
+            }
+        }
+    }));
+}

package/dist/utils/markdownEditor/wikilink.d.ts

@@ -0,0 +1,20 @@
+export declare const WIKILINK_NODE = "wikilink";
+export type WikilinkAttrs = {
+    target: string;
+    label: string;
+};
+type MdastNode = {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: unknown;
+};
+export declare function formatWikilink({ target, label }: WikilinkAttrs): string;
+/** Split one text value into text and wikilink pieces (empty when it has no links). */
+export declare function splitWikilinks(text: string): MdastNode[];
+export declare const remarkWikilink: import("@milkdown/kit/utils").$Remark<"remarkWikilink", unknown>;
+export declare const wikilinkNode: import("@milkdown/kit/utils").$Node;
+/** Typing the closing `]]` of `[[Something]]` turns it into a link. */
+export declare const wikilinkInputRule: import("@milkdown/kit/utils").$InputRule;
+export declare const wikilink: (import("@milkdown/kit/ctx").MilkdownPlugin | import("@milkdown/kit/utils").$Node | import("@milkdown/kit/utils").$Ctx<unknown, "remarkWikilink"> | import("@milkdown/kit/utils").$InputRule)[];
+export {};

package/dist/utils/markdownEditor/wikilink.js

@@ -0,0 +1,92 @@
+/**
+ * `[[target]]` and `[[target|label]]` links as an inline atom, so they round-trip to markdown
+ * unescaped and render as chips. Parsing splits remark text nodes; stringifying writes them raw.
+ */
+import { InputRule } from '@milkdown/kit/prose/inputrules';
+import { $inputRule, $node, $remark } from '@milkdown/kit/utils';
+export const WIKILINK_NODE = 'wikilink';
+const MDAST_TYPE = 'wikiLink';
+const WIKILINK = /\[\[([^\]|\n]+)(?:\|([^\]\n]+))?\]\]/g;
+export function formatWikilink({ target, label }) {
+    return label && label !== target ? `[[${target}|${label}]]` : `[[${target}]]`;
+}
+/** Split one text value into text and wikilink pieces (empty when it has no links). */
+export function splitWikilinks(text) {
+    const parts = [];
+    let last = 0;
+    for (const match of text.matchAll(WIKILINK)) {
+        const start = match.index ?? 0;
+        if (start > last)
+            parts.push({ type: 'text', value: text.slice(last, start) });
+        const target = match[1].trim();
+        parts.push({ type: MDAST_TYPE, data: { target, label: (match[2] ?? target).trim() } });
+        last = start + match[0].length;
+    }
+    if (!parts.length)
+        return [];
+    if (last < text.length)
+        parts.push({ type: 'text', value: text.slice(last) });
+    return parts;
+}
+function splitTree(node) {
+    if (!node.children)
+        return;
+    node.children = node.children.flatMap((child) => {
+        if (child.type === 'text' && child.value) {
+            const parts = splitWikilinks(child.value);
+            return parts.length ? parts : [child];
+        }
+        splitTree(child);
+        return [child];
+    });
+}
+export const remarkWikilink = $remark('remarkWikilink', () => function () {
+    const data = this.data();
+    (data.toMarkdownExtensions ??= []).push({
+        handlers: { [MDAST_TYPE]: (node) => formatWikilink(node.data) }
+    });
+    return (tree) => splitTree(tree);
+});
+export const wikilinkNode = $node(WIKILINK_NODE, () => ({
+    inline: true,
+    group: 'inline',
+    atom: true,
+    selectable: true,
+    marks: '',
+    attrs: { target: { default: '' }, label: { default: '' } },
+    parseDOM: [
+        {
+            tag: 'span[data-wikilink]',
+            getAttrs: (dom) => {
+                const el = dom;
+                return { target: el.dataset.wikilink ?? '', label: el.textContent ?? '' };
+            }
+        }
+    ],
+    toDOM: (node) => [
+        'span',
+        { 'data-wikilink': node.attrs.target, class: 'terminoir-md-wikilink', role: 'link', title: node.attrs.target },
+        node.attrs.label || node.attrs.target
+    ],
+    parseMarkdown: {
+        match: (node) => node.type === MDAST_TYPE,
+        runner: (state, node, type) => {
+            state.addNode(type, node.data);
+        }
+    },
+    toMarkdown: {
+        match: (node) => node.type.name === WIKILINK_NODE,
+        runner: (state, node) => {
+            state.addNode(MDAST_TYPE, undefined, undefined, { data: { target: node.attrs.target, label: node.attrs.label } });
+        }
+    }
+}));
+/** Typing the closing `]]` of `[[Something]]` turns it into a link. */
+export const wikilinkInputRule = $inputRule((ctx) => new InputRule(/\[\[([^\]|\n]+)(?:\|([^\]\n]+))?\]\]$/, (state, match, start, end) => {
+    const target = match[1].trim();
+    if (!target)
+        return null;
+    const node = wikilinkNode.type(ctx).create({ target, label: (match[2] ?? target).trim() });
+    return state.tr.replaceWith(start, end, node);
+}));
+export const wikilink = [remarkWikilink, wikilinkNode, wikilinkInputRule].flat();

package/dist/utils/timeline.d.ts

@@ -0,0 +1,36 @@
+export type TimelineItem = {
+    id: string;
+    title: string;
+    start: Date;
+    /** Inclusive last day; defaults to `start` (a one-day bar). */
+    end?: Date;
+    /** Palette name or CSS colour for the bar. */
+    color?: string;
+    /** Rows sharing a group sit under one heading. */
+    group?: string;
+};
+export type TimelineBar = {
+    item: TimelineItem;
+    left: number;
+    width: number;
+};
+export type TimelineRow = {
+    group: string | null;
+    bars: TimelineBar[];
+};
+export type TimelineScale = {
+    start: Date;
+    days: number;
+    ticks: {
+        date: Date;
+        left: number;
+    }[];
+};
+/** The day range covering every bar (padded a day each side) and evenly spaced day ticks. */
+export declare function timelineScale(items: TimelineItem[], today?: Date): TimelineScale;
+/** One bar per item as left/width percentages of the scale; ends before starts are clamped. */
+export declare function timelineBar(item: TimelineItem, scale: TimelineScale): TimelineBar;
+/** Bars in groups (first-seen order; ungrouped first), each group sorted by start. */
+export declare function timelineRows(items: TimelineItem[], scale: TimelineScale): TimelineRow[];
+/** Where today falls on the scale (percent), or null when outside it. */
+export declare function todayOffset(scale: TimelineScale, today?: Date): number | null;

package/dist/utils/timeline.js

@@ -0,0 +1,48 @@
+import { addDays, startOfDay } from './calendar.js';
+const DAY_MS = 86_400_000;
+const PAD_DAYS = 1;
+const MAX_TICKS = 12;
+function dayIndex(from, d) {
+    return Math.round((startOfDay(d).getTime() - from.getTime()) / DAY_MS);
+}
+/** The day range covering every bar (padded a day each side) and evenly spaced day ticks. */
+export function timelineScale(items, today = new Date()) {
+    const starts = items.map((i) => startOfDay(i.start).getTime());
+    const ends = items.map((i) => startOfDay(i.end ?? i.start).getTime());
+    const first = starts.length ? Math.min(...starts) : startOfDay(today).getTime();
+    const last = ends.length ? Math.max(...ends) : first;
+    const start = addDays(new Date(first), -PAD_DAYS);
+    const days = Math.round((last - first) / DAY_MS) + 1 + 2 * PAD_DAYS;
+    const step = Math.max(1, Math.ceil(days / MAX_TICKS));
+    const ticks = [];
+    for (let i = 0; i < days; i += step)
+        ticks.push({ date: addDays(start, i), left: (i / days) * 100 });
+    return { start, days, ticks };
+}
+/** One bar per item as left/width percentages of the scale; ends before starts are clamped. */
+export function timelineBar(item, scale) {
+    const from = dayIndex(scale.start, item.start);
+    const to = Math.max(from, dayIndex(scale.start, item.end ?? item.start));
+    return { item, left: (from / scale.days) * 100, width: ((to - from + 1) / scale.days) * 100 };
+}
+/** Bars in groups (first-seen order; ungrouped first), each group sorted by start. */
+export function timelineRows(items, scale) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = item.group ?? null;
+        groups.set(key, [...(groups.get(key) ?? []), item]);
+    }
+    const keys = [...groups.keys()].sort((a, b) => (a === null ? -1 : b === null ? 1 : 0));
+    return keys.map((group) => ({
+        group,
+        bars: (groups.get(group) ?? [])
+            .slice()
+            .sort((a, b) => a.start.getTime() - b.start.getTime())
+            .map((item) => timelineBar(item, scale)),
+    }));
+}
+/** Where today falls on the scale (percent), or null when outside it. */
+export function todayOffset(scale, today = new Date()) {
+    const i = dayIndex(scale.start, today);
+    return i < 0 || i >= scale.days ? null : ((i + 0.5) / scale.days) * 100;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "terminoir",
-  "version": "0.7.0",
-  "description": "Terminoir \u2014 Liquid Glass design tokens and Svelte 5 UI components.",
+  "version": "0.9.0",
+  "description": "Terminoir — Liquid Glass design tokens and Svelte 5 UI components.",
   "license": "Apache-2.0",
   "type": "module",
   "style": "./css/index.css",
@@ -85,6 +85,7 @@
     "@fontsource/source-code-pro": "^5.2.5",
     "@fontsource/source-sans-3": "^5.2.5",
     "@fontsource/source-serif-4": "^5.2.5",
+    "@milkdown/kit": "7.23.0",
     "@surdeddd/liquidglass": "^0.12.0"
   },
   "devDependencies": {