@leavepulse/ui 0.77.2 → 0.78.0

package/dist/components/fileTree.d.ts

@@ -81,3 +81,70 @@ export interface NodeStats {
 export declare function computeStats(nodes: FileNode[], checked: ReadonlySet<string>): Map<string, NodeStats>;
 /** Ids of every ancestor directory of `id`, so callers can reveal a deep node. */
 export declare function ancestorIds(nodes: FileNode[], id: string): string[];
+/** What narrows the tree. Every field is optional; all that are set must hold. */
+export interface FileTreeFilter {
+    /** Case-insensitive, against the entry's name and its path from the root. */
+    query?: string;
+    kind?: FileNode["kind"];
+    /** File extensions without the dot. A directory never matches one. */
+    extensions?: string[];
+    /** Bytes, inclusive. An entry with no `size` does not match. */
+    minSize?: number;
+    maxSize?: number;
+    /** Inclusive. An entry with no readable `modified` does not match. */
+    modifiedFrom?: Date | number;
+    modifiedTo?: Date | number;
+}
+/** A file's extension, lowercase. A leading dot starts a name, not an extension. */
+export declare function fileExtension(name: string): string;
+/** True when no field of the filter would narrow anything. */
+export declare function isFilterEmpty(filter: FileTreeFilter | undefined): boolean;
+/** Whether one entry, at this path, passes the filter on its own. */
+export declare function matchesFilter(node: FileNode, path: string, filter: FileTreeFilter): boolean;
+export interface FilteredTree {
+    nodes: FileNode[];
+    /** Directories that hold a match: shown open while the filter is on. */
+    openIds: Set<string>;
+}
+/**
+ * The tree with only the matches and the folders leading to them. A kept folder
+ * is a copy whose `children` are its kept entries, so what is ticked through it
+ * is what is shown. A folder that is not loaded keeps `children` undefined: only
+ * loaded entries can be searched.
+ */
+export declare function filterTree(nodes: FileNode[], filter: FileTreeFilter | undefined): FilteredTree;
+/** The tree with children fetched by `load` put in place. The app's own `children` win. */
+export declare function withLoadedChildren(nodes: FileNode[], loaded: ReadonlyMap<string, FileNode[]>): FileNode[];
+/** One row of the flattened tree, with what a flat DOM cannot imply to assistive tech. */
+export interface FlatRow {
+    node: FileNode;
+    depth: number;
+    /** Siblings at this level, and this row's 1-based place among them. */
+    setSize: number;
+    posInSet: number;
+}
+/** The visible rows in render order: open directories followed by their children. */
+export declare function flattenVisible(nodes: FileNode[], open: ReadonlySet<string>, sort: boolean): FlatRow[];
+export interface RowWindow {
+    /** First row to render, and one past the last. */
+    start: number;
+    end: number;
+}
+/** Which rows a scroll position shows, with `overscan` extra on each side. */
+export declare function rowWindow(scrollTop: number, viewport: number, rowHeight: number, total: number, overscan: number): RowWindow;
+/** Ids between two rows, inclusive, in row order; locked rows are left out. */
+export declare function rangeIds(rows: readonly FileNode[], anchor: string | undefined, target: string): string[];
+/** The chain from the root down to `id`, itself included. */
+export declare function nodeTrail(id: string, byId: ReadonlyMap<string, FileNode>, parentOf: ReadonlyMap<string, string>): FileNode[];
+/**
+ * Whether `sources` may land in `target`: a directory that is not one of them,
+ * not inside one of them, and not where all of them already are.
+ */
+export declare function canDrop(sources: readonly string[], target: FileNode, parentOf: ReadonlyMap<string, string>): boolean;
+/** Those of `ids` no other of them contains: a moved folder carries what is inside it. */
+export declare function topmostIds(ids: readonly string[], parentOf: ReadonlyMap<string, string>): string[];
+export type RenameProblem = "empty" | "separator" | "duplicate";
+/** Why a new name cannot stand, or null. An unchanged name is the caller's no-op. */
+export declare function renameProblem(name: string, node: FileNode, siblings: readonly FileNode[]): RenameProblem | null;
+/** How much of a name to select for renaming: the stem, so the extension survives typing. */
+export declare function renameSelectionEnd(node: FileNode): number;

package/dist/components/fileTree.js

@@ -1,3 +1,4 @@
+import { clamp } from "../composables/clamp.js";
 import { formatBytes } from "./format.js";
 const EXT_ICONS = {
   json: "lucide:file-json",
@@ -211,15 +212,154 @@ function ancestorIds(nodes, id) {
   walk(nodes, []);
   return path;
 }
+const PATH_SEPARATOR = "/";
+function fileExtension(name) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+}
+function modifiedTime(value) {
+  if (value === void 0) return Number.NaN;
+  return value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(value);
+}
+const timeOf = (value) => typeof value === "number" ? value : value.getTime();
+function isFilterEmpty(filter) {
+  if (!filter) return true;
+  return !filter.query?.trim() && filter.kind === void 0 && !filter.extensions?.length && filter.minSize === void 0 && filter.maxSize === void 0 && filter.modifiedFrom === void 0 && filter.modifiedTo === void 0;
+}
+function matchesFilter(node, path, filter) {
+  const needle = filter.query?.trim().toLowerCase();
+  if (needle && !node.name.toLowerCase().includes(needle) && !path.toLowerCase().includes(needle)) return false;
+  if (filter.kind && node.kind !== filter.kind) return false;
+  if (filter.extensions?.length) {
+    if (node.kind !== "file") return false;
+    const wanted = filter.extensions.map((ext) => ext.replace(/^\./, "").toLowerCase());
+    if (!wanted.includes(fileExtension(node.name))) return false;
+  }
+  if (filter.minSize !== void 0 || filter.maxSize !== void 0) {
+    if (node.size === void 0) return false;
+    if (filter.minSize !== void 0 && node.size < filter.minSize) return false;
+    if (filter.maxSize !== void 0 && node.size > filter.maxSize) return false;
+  }
+  if (filter.modifiedFrom !== void 0 || filter.modifiedTo !== void 0) {
+    const time = modifiedTime(node.modified);
+    if (Number.isNaN(time)) return false;
+    if (filter.modifiedFrom !== void 0 && time < timeOf(filter.modifiedFrom)) return false;
+    if (filter.modifiedTo !== void 0 && time > timeOf(filter.modifiedTo)) return false;
+  }
+  return true;
+}
+function filterTree(nodes, filter) {
+  const openIds = /* @__PURE__ */ new Set();
+  if (!filter || isFilterEmpty(filter)) return { nodes, openIds };
+  const active = filter;
+  function walk(list, parentPath) {
+    const kept = [];
+    for (const node of list) {
+      const path = parentPath ? `${parentPath}${PATH_SEPARATOR}${node.name}` : node.name;
+      const children = node.children && walk(node.children, path);
+      if (children?.length) {
+        openIds.add(node.id);
+        kept.push({ ...node, children });
+      } else if (matchesFilter(node, path, active)) {
+        kept.push(children ? { ...node, children } : node);
+      }
+    }
+    return kept;
+  }
+  return { nodes: walk(nodes, ""), openIds };
+}
+function withLoadedChildren(nodes, loaded) {
+  if (!loaded.size) return nodes;
+  return nodes.map((node) => {
+    if (node.kind !== "dir") return node;
+    const children = node.children ?? loaded.get(node.id);
+    if (!children) return node;
+    return { ...node, children: withLoadedChildren(children, loaded) };
+  });
+}
+function flattenVisible(nodes, open, sort) {
+  const rows = [];
+  function walk(list, depth) {
+    const ordered = sort ? sortNodes(list) : list;
+    ordered.forEach((node, index) => {
+      rows.push({ node, depth, setSize: ordered.length, posInSet: index + 1 });
+      if (node.kind === "dir" && open.has(node.id) && node.children?.length) walk(node.children, depth + 1);
+    });
+  }
+  walk(nodes, 0);
+  return rows;
+}
+function rowWindow(scrollTop, viewport, rowHeight, total, overscan) {
+  const first = Math.floor(Math.max(0, scrollTop) / rowHeight);
+  const count = Math.ceil(Math.max(0, viewport) / rowHeight);
+  return {
+    start: clamp(first - overscan, 0, total),
+    end: Math.min(total, first + count + overscan)
+  };
+}
+function rangeIds(rows, anchor, target) {
+  const to = rows.findIndex((node) => node.id === target);
+  if (to < 0) return [];
+  const found = anchor === void 0 ? -1 : rows.findIndex((node) => node.id === anchor);
+  const from = found < 0 ? to : found;
+  return rows.slice(Math.min(from, to), Math.max(from, to) + 1).filter((node) => !node.disabled).map((node) => node.id);
+}
+function nodeTrail(id, byId, parentOf) {
+  const trail = [];
+  for (let at = id; at !== void 0; at = parentOf.get(at)) {
+    const node = byId.get(at);
+    if (node) trail.unshift(node);
+  }
+  return trail;
+}
+function canDrop(sources, target, parentOf) {
+  if (target.kind !== "dir" || target.disabled || !sources.length) return false;
+  for (let at = target.id; at !== void 0; at = parentOf.get(at)) {
+    if (sources.includes(at)) return false;
+  }
+  return sources.some((id) => parentOf.get(id) !== target.id);
+}
+function topmostIds(ids, parentOf) {
+  const all = new Set(ids);
+  return ids.filter((id) => {
+    for (let at = parentOf.get(id); at !== void 0; at = parentOf.get(at)) {
+      if (all.has(at)) return false;
+    }
+    return true;
+  });
+}
+function renameProblem(name, node, siblings) {
+  const next = name.trim();
+  if (!next) return "empty";
+  if (/[/\\\0]/.test(next)) return "separator";
+  return siblings.some((other) => other.id !== node.id && other.name === next) ? "duplicate" : null;
+}
+function renameSelectionEnd(node) {
+  const dot = node.name.lastIndexOf(".");
+  return node.kind === "file" && dot > 0 ? dot : node.name.length;
+}
 export {
   ancestorIds,
+  canDrop,
   checkStateOf,
   checkedCount,
   computeStats,
+  fileExtension,
   fileIcon,
+  filterTree,
+  flattenVisible,
   formatModified,
   formatSize,
+  isFilterEmpty,
+  matchesFilter,
+  nodeTrail,
+  rangeIds,
+  renameProblem,
+  renameSelectionEnd,
+  rowWindow,
   sortNodes,
   subtreeIds,
-  subtreeSize
+  subtreeSize,
+  topmostIds,
+  withLoadedChildren
 };

package/dist/components/identicon.js

@@ -1,3 +1,4 @@
+import { clamp } from "../composables/clamp.js";
 function hashString(seed) {
   let h = 2166136261;
   for (let i = 0; i < seed.length; i++) {
@@ -16,7 +17,7 @@ function generator(seed) {
   };
 }
 function identicon(seed, options = {}) {
-  const size = Math.max(3, Math.min(12, Math.round(options.grid ?? 5)));
+  const size = clamp(Math.round(options.grid ?? 5), 3, 12);
   const [sMin, sMax] = options.saturation ?? [55, 72];
   const [lMin, lMax] = options.lightness ?? [48, 60];
   const next = generator(hashString(seed));
@@ -70,7 +71,7 @@ function identiconRects(cells) {
 function identiconSvg(seed, options = {}) {
   const { cells, color } = identicon(seed, options);
   const n = cells.length;
-  const pad = n * Math.max(0, Math.min(0.4, options.padding ?? 0.12));
+  const pad = n * clamp(options.padding ?? 0.12, 0, 0.4);
   const view = n + pad * 2;
   const px = options.size ?? 64;
   const bg = options.background ? `<rect width="${view}" height="${view}" fill="${options.background}"/>` : "";

package/dist/components/logTools.d.ts

@@ -0,0 +1,93 @@
+export declare const MAX_PATTERN_LENGTH = 200;
+export declare const MAX_MATCH_INPUT = 2000;
+export declare const MATCH_BUDGET_MS = 50;
+export type PatternError = "too-long" | "unsafe" | "invalid";
+export interface LogPattern {
+    test(text: string): boolean;
+    ranges(text: string): [number, number][];
+}
+export declare function compilePattern(source: string): {
+    pattern: LogPattern | null;
+    error: PatternError | null;
+};
+/** Positions of the rows the pattern finds, giving up once the budget is spent. */
+export declare function patternPositions(rows: readonly {
+    message: string;
+    source?: string;
+}[], pattern: LogPattern, now?: () => number): number[];
+/** Every occurrence of a plain term, case-insensitive. */
+export declare function termRanges(text: string, term: string): [number, number][];
+/** A line's time as epoch ms; a pre-formatted label ("12:03:05") has none. */
+export declare function timeMs(time: number | string | undefined): number | null;
+export interface LogTimeRange {
+    from?: number | string;
+    to?: number | string;
+}
+/**
+ * Inclusive at both ends. A line with no readable time stays: most are the
+ * continuation of the entry above (a stack frame), and hiding them would cut
+ * the entries the range keeps in half.
+ */
+export declare function inTimeRange(time: number | string | undefined, range: LogTimeRange | undefined): boolean;
+/** The position of the row closest in time, -1 when none has a readable time. */
+export declare function nearestByTime(rows: readonly {
+    time?: number | string;
+}[], target: number | string): number;
+/** A message with its volatile parts (numbers, ids, hashes) blanked, so repeats compare equal. */
+export declare function messageShape(message: string): string;
+export interface RepeatRow<L> {
+    line: L;
+    n: number;
+    count: number;
+}
+/** Folds rows of the same level, source and shape into the first, wherever they sit. */
+export declare function groupRepeats<L extends {
+    message: string;
+    level?: string;
+    source?: string;
+}>(rows: readonly {
+    line: L;
+    n: number;
+}[]): RepeatRow<L>[];
+export type LogIdKind = "trace" | "request" | "span" | "correlation";
+export interface LogId {
+    kind: LogIdKind;
+    value: string;
+    start: number;
+    end: number;
+}
+/** The correlation ids a message carries, as `trace_id=abc` or `"requestId": "abc"`. */
+export declare function findIds(message: string): LogId[];
+export interface MessagePart {
+    text: string;
+    hit: boolean;
+    id?: LogId;
+}
+/** A message cut around its search hits and ids. An id wins where the two overlap. */
+export declare function messageParts(message: string, hits: readonly [number, number][], ids: readonly LogId[]): MessagePart[];
+/** The object or array a message holds, whole or after a text prefix; null when it holds none. */
+export declare function structuredPayload(message: string): object | null;
+export interface JsonRow {
+    path: string;
+    depth: number;
+    label: string;
+    /** Rendered value; for an object or array its size, as `{3}` or `[3]`. */
+    value: string;
+    kind: "object" | "array" | "string" | "number" | "boolean" | "null";
+    expandable: boolean;
+}
+/**
+ * A payload as flat rows, skipping what is collapsed. With `filter`, only the
+ * fields whose name or value hold it, plus the parents leading to them.
+ */
+export declare function jsonRows(root: object, collapsed: ReadonlySet<string>, filter?: string): JsonRow[];
+/** Text split into lines, with a stack's frames marked; null when it holds no stack. */
+export declare function stackLines(text: string): {
+    text: string;
+    frame: boolean;
+}[] | null;
+export type LogExportFormat = "text" | "ndjson";
+/** Lines as a file: readable text, or one JSON object per line. */
+export declare function exportLines<L>(lines: readonly L[], format: LogExportFormat, asText: (line: L) => string): string;
+/** The inclusive run between two row numbers, whichever order they came in. */
+export declare function rowSpan(from: number, to: number): [number, number];

package/dist/components/logTools.js

@@ -0,0 +1,210 @@
+const MAX_PATTERN_LENGTH = 200;
+const MAX_MATCH_INPUT = 2e3;
+const MATCH_BUDGET_MS = 50;
+const NESTED_QUANTIFIER = /\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)\s*(?:[+*]|\{\d+,\d*\})/;
+function compilePattern(source) {
+  if (source.length > MAX_PATTERN_LENGTH) return { pattern: null, error: "too-long" };
+  if (NESTED_QUANTIFIER.test(source)) return { pattern: null, error: "unsafe" };
+  let regex;
+  try {
+    regex = new RegExp(source, "giu");
+  } catch {
+    return { pattern: null, error: "invalid" };
+  }
+  const capped = (text) => text.length > MAX_MATCH_INPUT ? text.slice(0, MAX_MATCH_INPUT) : text;
+  return {
+    error: null,
+    pattern: {
+      test(text) {
+        regex.lastIndex = 0;
+        return regex.test(capped(text));
+      },
+      ranges(text) {
+        const out = [];
+        regex.lastIndex = 0;
+        for (const match of capped(text).matchAll(regex)) {
+          if (match[0]) out.push([match.index, match.index + match[0].length]);
+        }
+        return out;
+      }
+    }
+  };
+}
+function patternPositions(rows, pattern, now = () => performance.now()) {
+  const out = [];
+  const deadline = now() + MATCH_BUDGET_MS;
+  for (let i = 0; i < rows.length; i++) {
+    if (now() > deadline) break;
+    const row = rows[i];
+    if (pattern.test(row.message) || row.source !== void 0 && pattern.test(row.source)) out.push(i);
+  }
+  return out;
+}
+function termRanges(text, term) {
+  const needle = term.toLowerCase();
+  if (!needle) return [];
+  const lower = text.toLowerCase();
+  const out = [];
+  for (let at = lower.indexOf(needle); at !== -1; at = lower.indexOf(needle, at + needle.length)) {
+    out.push([at, at + needle.length]);
+  }
+  return out;
+}
+function timeMs(time) {
+  if (time == null) return null;
+  if (typeof time === "number") return Number.isFinite(time) ? time : null;
+  if (/^\d+$/.test(time)) return Number(time);
+  const parsed = Date.parse(time);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function inTimeRange(time, range) {
+  if (!range) return true;
+  const at = timeMs(time);
+  if (at === null) return true;
+  const from = timeMs(range.from);
+  const to = timeMs(range.to);
+  return (from === null || at >= from) && (to === null || at <= to);
+}
+function nearestByTime(rows, target) {
+  const wanted = timeMs(target);
+  if (wanted === null) return -1;
+  let best = -1;
+  let distance = Infinity;
+  rows.forEach((row, i) => {
+    const at = timeMs(row.time);
+    if (at === null) return;
+    const gap = Math.abs(at - wanted);
+    if (gap < distance) {
+      best = i;
+      distance = gap;
+    }
+  });
+  return best;
+}
+const VOLATILE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b|\b0x[0-9a-f]+\b|\b[0-9a-f]{16,}\b|\d+(?:\.\d+)*/gi;
+function messageShape(message) {
+  return message.replace(VOLATILE, "#");
+}
+function groupRepeats(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const { line, n } of rows) {
+    const key = [line.level ?? "", line.source ?? "", messageShape(line.message)].join("\0");
+    const group = groups.get(key);
+    if (group) group.count++;
+    else groups.set(key, { line, n, count: 1 });
+  }
+  return [...groups.values()];
+}
+const ID_PATTERN = /\b(trace|request|req|span|correlation|corr)[_-]?id["']?\s*[=:]\s*["']?([\w-]{6,})/gi;
+const ID_KINDS = {
+  trace: "trace",
+  request: "request",
+  req: "request",
+  span: "span",
+  correlation: "correlation",
+  corr: "correlation"
+};
+function findIds(message) {
+  const out = [];
+  for (const match of message.matchAll(ID_PATTERN)) {
+    const value = match[2];
+    const start = match.index + match[0].length - value.length;
+    out.push({ kind: ID_KINDS[match[1].toLowerCase()], value, start, end: start + value.length });
+  }
+  return out;
+}
+function messageParts(message, hits, ids) {
+  const parts = [];
+  const plain = (from, to) => {
+    let at2 = from;
+    for (const [start, end] of hits) {
+      if (end <= at2 || start >= to) continue;
+      if (start > at2) parts.push({ text: message.slice(at2, start), hit: false });
+      const stop = Math.min(end, to);
+      parts.push({ text: message.slice(Math.max(start, at2), stop), hit: true });
+      at2 = stop;
+    }
+    if (at2 < to) parts.push({ text: message.slice(at2, to), hit: false });
+  };
+  let at = 0;
+  for (const id of ids) {
+    plain(at, id.start);
+    parts.push({ text: message.slice(id.start, id.end), hit: false, id });
+    at = id.end;
+  }
+  plain(at, message.length);
+  return parts.length ? parts : [{ text: message, hit: false }];
+}
+function structuredPayload(message) {
+  const start = message.search(/[{[]/);
+  if (start < 0) return null;
+  try {
+    const value = JSON.parse(message.slice(start));
+    return typeof value === "object" && value !== null ? value : null;
+  } catch {
+    return null;
+  }
+}
+function kindOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean" ? type : "object";
+}
+function holds(value, needle, label) {
+  if (label.toLowerCase().includes(needle)) return true;
+  if (value !== null && typeof value === "object") {
+    return Object.entries(value).some(([key, child]) => holds(child, needle, key));
+  }
+  return String(value).toLowerCase().includes(needle);
+}
+function jsonRows(root, collapsed, filter = "") {
+  const needle = filter.trim().toLowerCase();
+  const rows = [];
+  const walk = (value, parent, depth) => {
+    for (const [label, child] of Object.entries(value)) {
+      if (needle && !holds(child, needle, label)) continue;
+      const path = parent ? `${parent}.${label}` : label;
+      const kind = kindOf(child);
+      const nested = kind === "object" || kind === "array";
+      const size = nested ? Object.keys(child).length : 0;
+      const shown = kind === "array" ? `[${size}]` : kind === "object" ? `{${size}}` : kind === "string" ? child : String(child);
+      rows.push({ path, depth, label, value: shown, kind, expandable: nested && size > 0 });
+      if (nested && !collapsed.has(path)) walk(child, path, depth + 1);
+    }
+  };
+  walk(root, "", 0);
+  return rows;
+}
+const STACK_FRAME = /^\s*(?:at\s+\S|File ".+", line \d+|#\d+\s|\S+\.\w+:\d+)/;
+function stackLines(text) {
+  const lines = text.split(/\r?\n/).map((line) => ({ text: line, frame: STACK_FRAME.test(line) }));
+  return lines.length > 1 && lines.some((line) => line.frame) ? lines : null;
+}
+function exportLines(lines, format, asText) {
+  const rows = format === "ndjson" ? lines.map((line) => JSON.stringify(line)) : lines.map(asText);
+  return rows.join("\n");
+}
+function rowSpan(from, to) {
+  return from <= to ? [from, to] : [to, from];
+}
+export {
+  MATCH_BUDGET_MS,
+  MAX_MATCH_INPUT,
+  MAX_PATTERN_LENGTH,
+  compilePattern,
+  exportLines,
+  findIds,
+  groupRepeats,
+  inTimeRange,
+  jsonRows,
+  messageParts,
+  messageShape,
+  nearestByTime,
+  patternPositions,
+  rowSpan,
+  stackLines,
+  structuredPayload,
+  termRanges,
+  timeMs
+};

package/dist/components/menuWhen.js

@@ -1,5 +1,5 @@
 import { defineComponent, h } from "vue";
-import { _ as _sfc_main } from "../chunks/LpContextMenu-rx2tCjwk.js";
+import { _ as _sfc_main } from "../chunks/LpContextMenu--eMGIql6.js";
 const MenuWhen = defineComponent({
   name: "MenuWhen",
   inheritAttrs: false,

package/dist/components/meter.js

@@ -1,3 +1,4 @@
+import { clamp } from "../composables/clamp.js";
 import { TONES, TONE_ALIASES } from "./tone.js";
 const METER_TONES = ["ok", "warning", "danger", "brand", "neutral"];
 const byMeterTone = (pick) => Object.fromEntries(METER_TONES.map((t) => [t, pick(TONES[TONE_ALIASES[t]])]));
@@ -6,7 +7,7 @@ const TONE_SOFT = byMeterTone((look) => look.soft);
 function meterFraction(value, min, max) {
   const span = max - min;
   if (!(span > 0) || !Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, (value - min) / span));
+  return clamp((value - min) / span, 0, 1);
 }
 function capacityThresholds(min, max, warnAt = 0.8, dangerAt = 0.9) {
   const span = max - min;

package/dist/components/pipeline.d.ts

@@ -53,3 +53,5 @@ export declare function childProgress(step: PipelineStep): {
 } | null;
 /** The key a step is addressed by. */
 export declare function stepKey(step: Pick<PipelineStep, "key">, index: number): string;
+/** Keys used by more than one step, which would then share their open state. */
+export declare function duplicateStepKeys(steps: readonly Pick<PipelineStep, "key">[]): string[];

package/dist/components/pipeline.js

@@ -40,10 +40,15 @@ function childProgress(step) {
 function stepKey(step, index) {
   return step.key ?? String(index);
 }
+function duplicateStepKeys(steps) {
+  const keys = steps.map(stepKey);
+  return [...new Set(keys.filter((key, i) => keys.indexOf(key) !== i))];
+}
 export {
   childProgress,
   connectorFilled,
   currentStepIndex,
+  duplicateStepKeys,
   isSettled,
   overallStatus,
   stepElapsed,

package/dist/components/relativeTime.js

@@ -1,3 +1,4 @@
+import { clamp } from "../composables/clamp.js";
 import { toEpoch } from "./timeSpan.js";
 const SECOND = 1e3;
 const MINUTE = 60 * SECOND;
@@ -49,7 +50,7 @@ function formatRelativeTime(date, now = Date.now(), options = {}) {
   return { text: fmt.format(value, step.unit), unit: step.unit, value, refreshIn: clampRefresh(refreshIn) };
 }
 function clampRefresh(ms) {
-  return Math.min(MAX_REFRESH, Math.max(MIN_REFRESH, Math.ceil(ms)));
+  return clamp(Math.ceil(ms), MIN_REFRESH, MAX_REFRESH);
 }
 export {
   formatRelativeTime

package/dist/components/reveal.js

@@ -1,3 +1,4 @@
+import { clamp } from "../composables/clamp.js";
 function revealFrom(preset, direction, distance) {
   const offset = (d) => ({
     up: `translate3d(0, ${d}px, 0)`,
@@ -23,7 +24,7 @@ function revealTo(from) {
   return to;
 }
 function staggerDelay(index, delay, stagger, cap = 10) {
-  return delay + Math.min(Math.max(0, index), cap) * Math.max(0, stagger);
+  return delay + clamp(index, 0, cap) * Math.max(0, stagger);
 }
 export {
   revealFrom,

package/dist/components/select.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Drop the oldest entries past `limit`, never one of `keep`. For a cache that
+ * must outlive the list it was read from, in a long session over a big catalog.
+ */
+export declare function evictOldest<K, V>(cache: Map<K, V>, keep: ReadonlySet<K>, limit: number): void;
 /**
  * How many chips of a multiple pick fit in one row before the rest collapse
  * into a "+N" chip.

package/dist/components/select.js

@@ -1,3 +1,12 @@
+function evictOldest(cache, keep, limit) {
+  let excess = cache.size - limit;
+  for (const key of cache.keys()) {
+    if (excess <= 0) return;
+    if (keep.has(key)) continue;
+    cache.delete(key);
+    excess--;
+  }
+}
 function fitChips(widths, available, gap, moreWidth) {
   const n = widths.length;
   if (n === 0) return 0;
@@ -19,6 +28,7 @@ function toggledValues(previous, next) {
   return [...next.filter((v) => !before.has(v)), ...previous.filter((v) => !after.has(v))];
 }
 export {
+  evictOldest,
   fitChips,
   toggledValues
 };

package/dist/components/sidebar.d.ts

@@ -40,6 +40,7 @@ export interface SidebarItem {
      * away without opening the section first. In a compact sidebar they open in
      * a card beside the icon.
      */
+    /** One level: search, the active row and the rail stop at these pages, nothing under them is drawn. */
     children?: SidebarItem[];
     /** A dot instead of a count: something new here that has no number to it. */
     dot?: boolean;