@heyramzi/ui 2.11.0 → 2.11.2

package/dist/work/gantt/logic.js

@@ -1,260 +1,236 @@
 import { dayNumber, isoFromDay, weekday } from "../dates.js";
-const DAY_MS = 86_400_000;
+const DAY_MS = 864e5;
 export function dayX(layout, day) {
-    return (day - layout.first) * layout.dayWidth;
+	return (day - layout.first) * layout.dayWidth;
 }
+/** The task's own dates. A lone date stands for a one-day task. */
 export function spanOf(item, { getStart, getEnd }) {
-    const first = getStart(item) || getEnd(item);
-    const last = getEnd(item) || getStart(item);
-    if (!first || !last) return null;
-    const start = dayNumber(first);
-    return {
-        start,
-        end: Math.max(start, dayNumber(last))
-    };
+	const first = getStart(item) || getEnd(item);
+	const last = getEnd(item) || getStart(item);
+	if (!first || !last) return null;
+	const start = dayNumber(first);
+	return {
+		start,
+		end: Math.max(start, dayNumber(last))
+	};
 }
+/** A bar's span, with the live drag applied. Resizes never cross the other edge. */
 export function liveSpan(span, drag, id) {
-    if (!span || drag?.id !== id || drag.dx === 0) return span;
-    if (drag.mode === "move") return {
-        start: span.start + drag.dx,
-        end: span.end + drag.dx
-    };
-    if (drag.mode === "start") return {
-        start: Math.min(span.start + drag.dx, span.end),
-        end: span.end
-    };
-    return {
-        start: span.start,
-        end: Math.max(span.end + drag.dx, span.start)
-    };
+	if (!span || drag?.id !== id || drag.dx === 0) return span;
+	if (drag.mode === "move") return {
+		start: span.start + drag.dx,
+		end: span.end + drag.dx
+	};
+	if (drag.mode === "start") return {
+		start: Math.min(span.start + drag.dx, span.end),
+		end: span.end
+	};
+	return {
+		start: span.start,
+		end: Math.max(span.end + drag.dx, span.start)
+	};
 }
 function join(a, b) {
-    return !a ? b : !b ? a : {
-        start: Math.min(a.start, b.start),
-        end: Math.max(a.end, b.end)
-    };
+	return !a ? b : !b ? a : {
+		start: Math.min(a.start, b.start),
+		end: Math.max(a.end, b.end)
+	};
 }
+/** The days shown: the tasks' span, padded, starting on a Monday, unless `from` and `to` say otherwise. */
 export function rangeOf(items, source, todayDay, from, to) {
-    let lo = todayDay;
-    let hi = todayDay;
-    for (const item of items){
-        const span = spanOf(item, source);
-        if (!span) continue;
-        lo = Math.min(lo, span.start);
-        hi = Math.max(hi, span.end);
-    }
-    let first = from ? dayNumber(from) : lo - 7;
-    if (!from) first -= (weekday(first) + 6) % 7;
-    const last = to ? dayNumber(to) : hi + 21;
-    return {
-        first,
-        last: Math.max(last, first)
-    };
+	let lo = todayDay;
+	let hi = todayDay;
+	for (const item of items) {
+		const span = spanOf(item, source);
+		if (!span) continue;
+		lo = Math.min(lo, span.start);
+		hi = Math.max(hi, span.end);
+	}
+	let first = from ? dayNumber(from) : lo - 7;
+	// Day 0 was a Thursday. Step back to the Monday on or before `first`.
+	if (!from) first -= (weekday(first) + 6) % 7;
+	const last = to ? dayNumber(to) : hi + 21;
+	return {
+		first,
+		last: Math.max(last, first)
+	};
 }
 export function buildDays(first, count) {
-    return Array.from({
-        length: count
-    }, (_, i)=>{
-        const day = first + i;
-        const wd = weekday(day);
-        return {
-            day,
-            i,
-            date: Number(isoFromDay(day).slice(8, 10)),
-            wd,
-            weekend: wd === 0 || wd === 6
-        };
-    });
+	return Array.from({ length: count }, (_, i) => {
+		const day = first + i;
+		const wd = weekday(day);
+		return {
+			day,
+			i,
+			date: Number(isoFromDay(day).slice(8, 10)),
+			wd,
+			weekend: wd === 0 || wd === 6
+		};
+	});
 }
 export function buildMonths(days, format) {
-    const out = [];
-    for (const d of days){
-        const key = isoFromDay(d.day).slice(0, 7);
-        const last = out.at(-1);
-        if (last?.key === key) last.length++;
-        else out.push({
-            key,
-            label: format.format(new Date(d.day * DAY_MS)),
-            i: d.i,
-            length: 1
-        });
-    }
-    return out;
+	const out = [];
+	for (const d of days) {
+		const key = isoFromDay(d.day).slice(0, 7);
+		const last = out.at(-1);
+		if (last?.key === key) last.length++;
+		else out.push({
+			key,
+			label: format.format(new Date(d.day * DAY_MS)),
+			i: d.i,
+			length: 1
+		});
+	}
+	return out;
 }
+/** Rows in draw order. Groups come first, then their tasks, a parent before its children. */
 export function buildRows(items, source) {
-    const { getId, getParent, groups, getGroup, folded, drag } = source;
-    const out = [];
-    let order = 0;
-    const live = (item, id)=>liveSpan(spanOf(item, source), drag, id);
-    const emit = (members)=>{
-        if (!getParent) {
-            for (const item of members){
-                const id = getId(item);
-                const own = live(item, id);
-                out.push({
-                    kind: "task",
-                    item,
-                    id,
-                    order: order++,
-                    depth: 0,
-                    hasChildren: false,
-                    open: true,
-                    own,
-                    span: own
-                });
-            }
-            return;
-        }
-        const ids = new Set(members.map((item)=>getId(item)));
-        const kids = new Map();
-        for (const item of members){
-            const parent = getParent(item);
-            const key = parent && ids.has(parent) ? parent : null;
-            kids.set(key, [
-                ...kids.get(key) ?? [],
-                item
-            ]);
-        }
-        const walk = (item, depth, visible)=>{
-            const id = getId(item);
-            const children = kids.get(id) ?? [];
-            const open = !folded.has(id);
-            const own = live(item, id);
-            const row = {
-                kind: "task",
-                item,
-                id,
-                order: 0,
-                depth,
-                hasChildren: children.length > 0,
-                open,
-                own,
-                span: own
-            };
-            if (visible) {
-                row.order = order++;
-                out.push(row);
-            }
-            let below = null;
-            for (const child of children)below = join(below, walk(child, depth + 1, visible && open));
-            if (!own) row.span = below;
-            return join(own, below);
-        };
-        for (const item of kids.get(null) ?? [])walk(item, 0, true);
-    };
-    if (!groups || !getGroup) {
-        emit(items);
-        return out;
-    }
-    for (const group of groups){
-        const members = items.filter((item)=>getGroup(item) === group.id);
-        let span = null;
-        for (const item of members)span = join(span, live(item, getId(item)));
-        out.push({
-            kind: "group",
-            group,
-            count: members.length,
-            span
-        });
-        emit(members);
-    }
-    return out;
+	const { getId, getParent, groups, getGroup, folded, drag } = source;
+	const out = [];
+	let order = 0;
+	const live = (item, id) => liveSpan(spanOf(item, source), drag, id);
+	// Depth first, so a parent's row comes before its children. A parent's span is known
+	// only after its children are, so the row is pushed first and filled in after.
+	const emit = (members) => {
+		if (!getParent) {
+			for (const item of members) {
+				const id = getId(item);
+				const own = live(item, id);
+				out.push({
+					kind: "task",
+					item,
+					id,
+					order: order++,
+					depth: 0,
+					hasChildren: false,
+					open: true,
+					own,
+					span: own
+				});
+			}
+			return;
+		}
+		const ids = new Set(members.map((item) => getId(item)));
+		const kids = new Map();
+		for (const item of members) {
+			const parent = getParent(item);
+			const key = parent && ids.has(parent) ? parent : null;
+			kids.set(key, [...kids.get(key) ?? [], item]);
+		}
+		const walk = (item, depth, visible) => {
+			const id = getId(item);
+			const children = kids.get(id) ?? [];
+			const open = !folded.has(id);
+			const own = live(item, id);
+			const row = {
+				kind: "task",
+				item,
+				id,
+				order: 0,
+				depth,
+				hasChildren: children.length > 0,
+				open,
+				own,
+				span: own
+			};
+			if (visible) {
+				row.order = order++;
+				out.push(row);
+			}
+			let below = null;
+			for (const child of children) below = join(below, walk(child, depth + 1, visible && open));
+			if (!own) row.span = below;
+			return join(own, below);
+		};
+		for (const item of kids.get(null) ?? []) walk(item, 0, true);
+	};
+	if (!groups || !getGroup) {
+		emit(items);
+		return out;
+	}
+	for (const group of groups) {
+		const members = items.filter((item) => getGroup(item) === group.id);
+		let span = null;
+		for (const item of members) span = join(span, live(item, getId(item)));
+		out.push({
+			kind: "group",
+			group,
+			count: members.length,
+			span
+		});
+		emit(members);
+	}
+	return out;
 }
+/** A right-angled path through `points`, each corner rounded by up to `radius`. */
 export function roundedPath(points, radius) {
-    let d = `M${points[0][0]},${points[0][1]}`;
-    for(let i = 1; i < points.length - 1; i++){
-        const [px, py] = points[i - 1];
-        const [cx, cy] = points[i];
-        const [nx, ny] = points[i + 1];
-        const r = Math.min(radius, Math.hypot(cx - px, cy - py) / 2, Math.hypot(nx - cx, ny - cy) / 2);
-        const inX = cx - Math.sign(cx - px) * r;
-        const inY = cy - Math.sign(cy - py) * r;
-        const outX = cx + Math.sign(nx - cx) * r;
-        const outY = cy + Math.sign(ny - cy) * r;
-        d += ` L${inX},${inY} Q${cx},${cy} ${outX},${outY}`;
-    }
-    const [lx, ly] = points[points.length - 1];
-    return `${d} L${lx},${ly}`;
+	let d = `M${points[0][0]},${points[0][1]}`;
+	for (let i = 1; i < points.length - 1; i++) {
+		const [px, py] = points[i - 1];
+		const [cx, cy] = points[i];
+		const [nx, ny] = points[i + 1];
+		const r = Math.min(radius, Math.hypot(cx - px, cy - py) / 2, Math.hypot(nx - cx, ny - cy) / 2);
+		const inX = cx - Math.sign(cx - px) * r;
+		const inY = cy - Math.sign(cy - py) * r;
+		const outX = cx + Math.sign(nx - cx) * r;
+		const outY = cy + Math.sign(ny - cy) * r;
+		d += ` L${inX},${inY} Q${cx},${cy} ${outX},${outY}`;
+	}
+	const [lx, ly] = points[points.length - 1];
+	return `${d} L${lx},${ly}`;
 }
+/** Each arrow runs from the end of the task waited on to the start of the one waiting. */
 export function buildArrows(rows, layout, getDependsOn) {
-    const { rowHeight, inset } = layout;
-    const at = new Map();
-    rows.forEach((row, index)=>{
-        if (row.kind === "task" && row.span) at.set(row.id, {
-            row: index,
-            span: row.span
-        });
-    });
-    const out = [];
-    for (const row of rows){
-        if (row.kind !== "task") continue;
-        const target = at.get(row.id);
-        if (!target) continue;
-        for (const dep of getDependsOn(row.item) ?? []){
-            const source = at.get(dep);
-            if (!source) continue;
-            const x1 = dayX(layout, source.span.end + 1) - inset;
-            const y1 = source.row * rowHeight + rowHeight / 2;
-            const x2 = dayX(layout, target.span.start) + inset;
-            const y2 = target.row * rowHeight + rowHeight / 2;
-            const points = x2 - x1 >= 24 ? [
-                [
-                    x1,
-                    y1
-                ],
-                [
-                    x1 + 12,
-                    y1
-                ],
-                [
-                    x1 + 12,
-                    y2
-                ],
-                [
-                    x2,
-                    y2
-                ]
-            ] : [
-                [
-                    x1,
-                    y1
-                ],
-                [
-                    x1 + 10,
-                    y1
-                ],
-                [
-                    x1 + 10,
-                    y1 + (y2 > y1 ? rowHeight / 2 : -rowHeight / 2)
-                ],
-                [
-                    x2 - 12,
-                    y1 + (y2 > y1 ? rowHeight / 2 : -rowHeight / 2)
-                ],
-                [
-                    x2 - 12,
-                    y2
-                ],
-                [
-                    x2,
-                    y2
-                ]
-            ];
-            out.push({
-                key: `${dep}->${row.id}`,
-                d: roundedPath(points, 6),
-                head: `M${x2 - 5},${y2 - 3.5} L${x2},${y2} L${x2 - 5},${y2 + 3.5}`,
-                from: dep,
-                to: row.id
-            });
-        }
-    }
-    return out;
+	const { rowHeight, inset } = layout;
+	const at = new Map();
+	rows.forEach((row, index) => {
+		if (row.kind === "task" && row.span) at.set(row.id, {
+			row: index,
+			span: row.span
+		});
+	});
+	const out = [];
+	for (const row of rows) {
+		if (row.kind !== "task") continue;
+		const target = at.get(row.id);
+		if (!target) continue;
+		for (const dep of getDependsOn(row.item) ?? []) {
+			const source = at.get(dep);
+			if (!source) continue;
+			const x1 = dayX(layout, source.span.end + 1) - inset;
+			const y1 = source.row * rowHeight + rowHeight / 2;
+			const x2 = dayX(layout, target.span.start) + inset;
+			const y2 = target.row * rowHeight + rowHeight / 2;
+			// Room between the bars: one bend in the gap. No room: out, round the row gap, and back in.
+			const points = x2 - x1 >= 24 ? [
+				[x1, y1],
+				[x1 + 12, y1],
+				[x1 + 12, y2],
+				[x2, y2]
+			] : [
+				[x1, y1],
+				[x1 + 10, y1],
+				[x1 + 10, y1 + (y2 > y1 ? rowHeight / 2 : -rowHeight / 2)],
+				[x2 - 12, y1 + (y2 > y1 ? rowHeight / 2 : -rowHeight / 2)],
+				[x2 - 12, y2],
+				[x2, y2]
+			];
+			out.push({
+				key: `${dep}->${row.id}`,
+				d: roundedPath(points, 6),
+				head: `M${x2 - 5},${y2 - 3.5} L${x2},${y2} L${x2 - 5},${y2 + 3.5}`,
+				from: dep,
+				to: row.id
+			});
+		}
+	}
+	return out;
 }
+/** The pixel width of a span's bar, never under 8px. */
 export function barWidth(span, layout) {
-    return Math.max((span.end - span.start + 1) * layout.dayWidth - layout.inset * 2, 8);
+	return Math.max((span.end - span.start + 1) * layout.dayWidth - layout.inset * 2, 8);
 }
 export function rangeLabel(span, format) {
-    const length = span.end - span.start + 1;
-    return `${format.format(new Date(span.start * DAY_MS))} to ${format.format(new Date(span.end * DAY_MS))}, ${length} ${length === 1 ? "day" : "days"}`;
+	const length = span.end - span.start + 1;
+	return `${format.format(new Date(span.start * DAY_MS))} to ${format.format(new Date(span.end * DAY_MS))}, ${length} ${length === 1 ? "day" : "days"}`;
 }

package/dist/work/inbox/inbox-logic.js

@@ -1,94 +1,90 @@
+/** The draft to open on: the agent's pick, else the first. */
 export function startDraft(drafts, recommended) {
-    return drafts.find((draft)=>draft.templateId === recommended) ?? drafts[0];
+	return drafts.find((draft) => draft.templateId === recommended) ?? drafts[0];
 }
+/** A person can act on an item only while it waits for them. */
 export function isOpen(item) {
-    return item.tier === "ask" && item.state === "proposed";
+	return item.tier === "ask" && item.state === "proposed";
 }
 export function canUndo(item) {
-    return item.tier === "auto" && item.state === "done";
+	return item.tier === "auto" && item.state === "done";
 }
+/** Lowercase, one space between words, no trailing ellipsis: what two copies of a line share. */
 function plain(text) {
-    return text.replace(/(…|\.{3})\s*$/, "").replace(/\s+/g, " ").trim().toLowerCase();
+	return text.replace(/(…|\.{3})\s*$/, "").replace(/\s+/g, " ").trim().toLowerCase();
 }
+/**
+* Each fact once: a line that repeats the title or the command, even clipped, is dropped, and
+* one that starts with the title keeps only the rest.
+*/
 export function cardFacts(item) {
-    const { command, summary, detail } = item.proposal;
-    const shown = [
-        plain(item.title)
-    ];
-    if (command) shown.push(plain(`${command.tool}: ${command.text}`), plain(command.text));
-    const lines = [];
-    for (const raw of [
-        summary,
-        detail
-    ]){
-        let line = raw?.trim() ?? "";
-        const title = item.title.trim();
-        if (line.toLowerCase().startsWith(title.toLowerCase()) && line.length > title.length) {
-            line = line.slice(title.length).replace(/^[\s:.,;-]+/, "");
-        }
-        const key = plain(line);
-        if (!key || shown.some((seen)=>seen.includes(key) || key.includes(seen))) continue;
-        shown.push(key);
-        lines.push(line);
-    }
-    return {
-        lines,
-        command
-    };
+	const { command, summary, detail } = item.proposal;
+	const shown = [plain(item.title)];
+	if (command) shown.push(plain(`${command.tool}: ${command.text}`), plain(command.text));
+	const lines = [];
+	for (const raw of [summary, detail]) {
+		let line = raw?.trim() ?? "";
+		const title = item.title.trim();
+		if (line.toLowerCase().startsWith(title.toLowerCase()) && line.length > title.length) {
+			line = line.slice(title.length).replace(/^[\s:.,;-]+/, "");
+		}
+		const key = plain(line);
+		if (!key || shown.some((seen) => seen.includes(key) || key.includes(seen))) continue;
+		shown.push(key);
+		lines.push(line);
+	}
+	return {
+		lines,
+		command
+	};
 }
+/** The reasoning of a trace when no line of the card already says it. */
 export function freshReasoning(item, facts) {
-    const reasoning = item.trace.reasoning.trim();
-    const key = plain(reasoning);
-    if (!key) return "";
-    const said = [
-        item.title,
-        item.proposal.summary,
-        item.proposal.detail ?? "",
-        ...facts.lines
-    ].map(plain).filter(Boolean);
-    return said.some((line)=>line.includes(key) || key.includes(line)) ? "" : reasoning;
+	const reasoning = item.trace.reasoning.trim();
+	const key = plain(reasoning);
+	if (!key) return "";
+	const said = [
+		item.title,
+		item.proposal.summary,
+		item.proposal.detail ?? "",
+		...facts.lines
+	].map(plain).filter(Boolean);
+	return said.some((line) => line.includes(key) || key.includes(line)) ? "" : reasoning;
 }
 const ISO = /^\d{4}-\d{2}-\d{2}T/;
 const UNITS = [
-    [
-        604_800,
-        "week"
-    ],
-    [
-        86_400,
-        "day"
-    ],
-    [
-        3_600,
-        "hour"
-    ],
-    [
-        60,
-        "minute"
-    ]
+	[604800, "week"],
+	[86400, "day"],
+	[3600, "hour"],
+	[60, "minute"]
 ];
+/**
+* A time as a person says it: "3 hr. ago", "Oct 12". A host-formatted string stays as written,
+* and a raw ISO string never reaches the screen.
+*/
 export function whenOf(at, now = Date.now(), locale = "en-GB") {
-    if (!ISO.test(at)) return at;
-    const time = Date.parse(at);
-    if (Number.isNaN(time)) return "";
-    const seconds = Math.round((time - now) / 1000);
-    const age = Math.abs(seconds);
-    if (age >= 4 * 604_800) {
-        return new Intl.DateTimeFormat(locale, {
-            month: "short",
-            day: "numeric"
-        }).format(time);
-    }
-    const rtf = new Intl.RelativeTimeFormat(locale, {
-        numeric: "auto",
-        style: "short"
-    });
-    for (const [size, unit] of UNITS){
-        if (age >= size) return rtf.format(Math.round(seconds / size), unit);
-    }
-    return rtf.format(0, "second");
+	if (!ISO.test(at)) return at;
+	const time = Date.parse(at);
+	if (Number.isNaN(time)) return "";
+	const seconds = Math.round((time - now) / 1e3);
+	const age = Math.abs(seconds);
+	if (age >= 4 * 604800) {
+		return new Intl.DateTimeFormat(locale, {
+			month: "short",
+			day: "numeric"
+		}).format(time);
+	}
+	const rtf = new Intl.RelativeTimeFormat(locale, {
+		numeric: "auto",
+		style: "short"
+	});
+	for (const [size, unit] of UNITS) {
+		if (age >= size) return rtf.format(Math.round(seconds / size), unit);
+	}
+	return rtf.format(0, "second");
 }
+/** True when a key press belongs to a text field and so isn't a shortcut. */
 export function isTyping(target) {
-    if (!(target instanceof HTMLElement)) return false;
-    return target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName);
+	if (!(target instanceof HTMLElement)) return false;
+	return target.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(target.tagName);
 }