@leavepulse/ui 0.44.0 → 0.45.1

package/dist/components/LpTableFilter.vue.d.ts

@@ -0,0 +1,31 @@
+export interface TableFilterOption {
+    value: unknown;
+    label: string;
+    /** Rows holding the value; omitted when unknown (a server-backed table). */
+    count?: number;
+}
+export interface TableFilterLabels {
+    search: string;
+    all: string;
+    none: string;
+    invert: string;
+    only: string;
+    onlyShown: string;
+    addShown: string;
+    noValues: string;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    options: TableFilterOption[];
+    hidden: ReadonlySet<unknown>;
+    labels: TableFilterLabels;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:hidden": (value: Set<unknown>) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    options: TableFilterOption[];
+    hidden: ReadonlySet<unknown>;
+    labels: TableFilterLabels;
+}> & Readonly<{
+    "onUpdate:hidden"?: ((value: Set<unknown>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/LpTableFilter.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/LpTableFilter-BV8PpLM9.js";
+export {
+  _sfc_main as default
+};

package/dist/components/LpTabs.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpTabs-_qMVaZJ6.js";
+import { _ as _sfc_main } from "../chunks/LpTabs-29iW1XOx.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpTagsInput.vue.d.ts

@@ -0,0 +1,77 @@
+import { type TagDuplicates, type TagRejection, type TagValidator } from "./tags";
+declare const _default: typeof __VLS_export;
+export default _default;
+export type TagsInputLabels = {
+    remove: string;
+    duplicate: string;
+    max: string;
+    added: string;
+    removed: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<{
+    modelValue?: string[];
+    placeholder?: string;
+    /** Characters (or a RegExp) that end a tag while typing and split a paste. */
+    delimiter?: string | readonly string[] | RegExp;
+    /** At most this many tags. */
+    max?: number;
+    /**
+     * "reject" keeps a repeat typed with a note, "ignore" drops it with a passing
+     * note, "allow" keeps it. Either way the tag it repeats pulses.
+     */
+    duplicates?: TagDuplicates;
+    /** Return an error message to refuse a tag. */
+    validate?: TagValidator;
+    /** Applied to each tag before it is checked and stored (trim is always applied). */
+    normalize?: (tag: string) => string;
+    /** Turn leftover text into a tag when the field loses focus. */
+    addOnBlur?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    label?: string;
+    hint?: string;
+    error?: string;
+    labels?: Partial<TagsInputLabels>;
+}, {
+    focus: () => void | undefined;
+    add: (value: string) => string;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    blur: (event: FocusEvent) => any;
+    "update:modelValue": (value: string[]) => any;
+    reject: (rejected: TagRejection[]) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue?: string[];
+    placeholder?: string;
+    /** Characters (or a RegExp) that end a tag while typing and split a paste. */
+    delimiter?: string | readonly string[] | RegExp;
+    /** At most this many tags. */
+    max?: number;
+    /**
+     * "reject" keeps a repeat typed with a note, "ignore" drops it with a passing
+     * note, "allow" keeps it. Either way the tag it repeats pulses.
+     */
+    duplicates?: TagDuplicates;
+    /** Return an error message to refuse a tag. */
+    validate?: TagValidator;
+    /** Applied to each tag before it is checked and stored (trim is always applied). */
+    normalize?: (tag: string) => string;
+    /** Turn leftover text into a tag when the field loses focus. */
+    addOnBlur?: boolean;
+    disabled?: boolean;
+    invalid?: boolean;
+    required?: boolean;
+    label?: string;
+    hint?: string;
+    error?: string;
+    labels?: Partial<TagsInputLabels>;
+}> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onReject?: ((rejected: TagRejection[]) => any) | undefined;
+}>, {
+    modelValue: string[];
+    delimiter: string | readonly string[] | RegExp;
+    duplicates: TagDuplicates;
+    addOnBlur: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/LpTagsInput.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/LpTagsInput-D1SuqbhB.js";
+export {
+  _sfc_main as default
+};

package/dist/components/LpTextarea.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpTextarea-yP8hGedR.js";
+import { _ as _sfc_main } from "../chunks/LpTextarea-uuScWo6-.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpThemeProvider.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpThemeProvider-Wjm7Tuit.js";
+import { _ as _sfc_main } from "../chunks/LpThemeProvider-Be4r2TQX.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpThemeSwitcher.vue.d.ts

@@ -13,9 +13,9 @@ type __VLS_Props = {
     cycleThemes?: (string | TokenSet)[];
     /**
      * Trigger style:
-     *  - "swatch" (default): a square showing the active theme's brand colour.
+     *  - "swatch" (default): a round chip previewing the theme's surface and brand.
      *  - "icon": a sun/moon icon following the active theme's mode.
-     *  - "pill": swatch + the theme name in a pill (always shows the label).
+     *  - "pill": the chip and the theme name in a rounded pill.
      */
     variant?: "swatch" | "icon" | "pill";
     /** Show the active theme's name next to the trigger (forced on for "pill"). */

package/dist/components/LpThemeSwitcher.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpThemeSwitcher-CKLc10KZ.js";
+import { _ as _sfc_main } from "../chunks/LpThemeSwitcher-B4aVPbNC.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpTimeField.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpTimeField-C5HRgS5H.js";
+import { _ as _sfc_main } from "../chunks/LpTimeField-Cqe7fXnh.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpToaster.vue.d.ts

@@ -1,6 +1,8 @@
 type __VLS_Props = {
     labels?: Partial<{
         dismiss: string;
+        copy: string;
+        copied: string;
     }>;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/LpToaster.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpToaster--oT6lfhL.js";
+import { _ as _sfc_main } from "../chunks/LpToaster-DTtWuKvq.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpTooltip.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpTooltip-CBdzeKNf.js";
+import { _ as _sfc_main } from "../chunks/LpTooltip-CXVKcOXT.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpTopologyCanvas.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpTopologyCanvas-DocsLal3.js";
+import { _ as _sfc_main } from "../chunks/LpTopologyCanvas-6ozNrQKh.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpUptimeBar.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpUptimeBar-DLtxOMRy.js";
+import { _ as _sfc_main } from "../chunks/LpUptimeBar-ugcv25xj.js";
 export {
   _sfc_main as default
 };

package/dist/components/chart.js

@@ -45,8 +45,9 @@ const niceScale = (min, max, ticks) => {
   if (!Number.isFinite(min) || !Number.isFinite(max)) return { min: 0, max: 1, step: 1 };
   if (min === max) {
     const pad = Math.abs(min) || 1;
-    min -= pad / 2;
-    max += pad / 2;
+    min = min >= 0 ? Math.max(0, min - pad / 2) : min - pad / 2;
+    max = max <= 0 ? Math.min(0, max + pad / 2) : max + pad / 2;
+    if (min === max) max = min + pad;
   }
   const raw = (max - min) / Math.max(1, ticks);
   const mag = 10 ** Math.floor(Math.log10(raw));

package/dist/components/commandSearch.js

@@ -39,6 +39,9 @@ function score(command, terms) {
     if (!hit) return 0;
     total += hit;
   }
+  const typed = terms.include.join(" ");
+  if (typed && label === typed) total += 6;
+  else if (typed && label.startsWith(typed)) total += 2;
   return total;
 }
 function rankCommandItems(items, terms) {

package/dist/components/dateRange.d.ts

@@ -0,0 +1,43 @@
+import { type CalendarDate } from "@internationalized/date";
+export interface DateRange {
+    start: string;
+    end: string;
+}
+export interface DateRangePreset {
+    label: string;
+    range: () => DateRange;
+}
+export interface DateRangePresetLabels {
+    today: string;
+    last7: string;
+    last30: string;
+    thisMonth: string;
+    lastMonth: string;
+}
+/** The default preset list. `now` is injectable so the set can be tested. */
+export declare function defaultRangePresets(labels: DateRangePresetLabels, now?: () => CalendarDate): DateRangePreset[];
+export declare function parseIsoDay(iso: string | undefined): CalendarDate | undefined;
+/** A range with both ends parsed and in order, or undefined. */
+export declare function normalizeRange(range: Partial<DateRange> | undefined): DateRange | undefined;
+export declare function sameRange(a: Partial<DateRange> | undefined, b: Partial<DateRange> | undefined): boolean;
+/** Clip a preset to the allowed bounds; undefined when nothing of it is left. */
+export declare function clampRange(range: DateRange, min?: string, max?: string): DateRange | undefined;
+/**
+ * "Jun 3 – 18, 2026" style text: Intl's own range formatting collapses the
+ * shared month and year, which is how a range reads naturally in every locale.
+ */
+export declare function formatRange(range: DateRange, locale?: string, format?: Intl.DateTimeFormatOptions): string;
+export interface ReshapeRules {
+    /** Whether the moving end may land on this day (min, max, disabled). */
+    allowed?: (iso: string) => boolean;
+    /** Days a range may not include. */
+    unavailable?: (iso: string) => boolean;
+    /** Longest range, in days, counting both ends. */
+    maximumDays?: number;
+}
+/**
+ * The range one end makes when it is dragged to `moving` while the other stays
+ * at `anchor`; passing the anchor flips which end is which. Null when the result
+ * would break a rule, so a drag simply does not follow onto that day.
+ */
+export declare function reshapeRange(anchor: string, moving: string, rules?: ReshapeRules): DateRange | null;

package/dist/components/dateRange.js

@@ -0,0 +1,76 @@
+import { endOfMonth, startOfMonth, today, getLocalTimeZone, parseDate } from "@internationalized/date";
+function span(start, end) {
+  return { start: start.toString(), end: end.toString() };
+}
+function defaultRangePresets(labels, now = () => today(getLocalTimeZone())) {
+  return [
+    { label: labels.today, range: () => span(now(), now()) },
+    { label: labels.last7, range: () => span(now().subtract({ days: 6 }), now()) },
+    { label: labels.last30, range: () => span(now().subtract({ days: 29 }), now()) },
+    { label: labels.thisMonth, range: () => span(startOfMonth(now()), endOfMonth(now())) },
+    {
+      label: labels.lastMonth,
+      range: () => {
+        const previous = now().subtract({ months: 1 });
+        return span(startOfMonth(previous), endOfMonth(previous));
+      }
+    }
+  ];
+}
+function parseIsoDay(iso) {
+  if (!iso) return void 0;
+  try {
+    return parseDate(iso.slice(0, 10));
+  } catch {
+    return void 0;
+  }
+}
+function normalizeRange(range) {
+  const start = parseIsoDay(range?.start);
+  const end = parseIsoDay(range?.end);
+  if (!start || !end) return void 0;
+  return start.compare(end) <= 0 ? span(start, end) : span(end, start);
+}
+function sameRange(a, b) {
+  const x = normalizeRange(a);
+  const y = normalizeRange(b);
+  return !!x && !!y && x.start === y.start && x.end === y.end;
+}
+function clampRange(range, min, max) {
+  const r = normalizeRange(range);
+  if (!r) return void 0;
+  const start = min && r.start < min ? min : r.start;
+  const end = max && r.end > max ? max : r.end;
+  return start <= end ? { start, end } : void 0;
+}
+function formatRange(range, locale, format = { year: "numeric", month: "short", day: "numeric" }) {
+  const start = parseIsoDay(range.start);
+  const end = parseIsoDay(range.end);
+  if (!start || !end) return "";
+  const zone = "UTC";
+  const fmt = new Intl.DateTimeFormat(locale, { ...format, timeZone: zone });
+  return fmt.formatRange(start.toDate(zone), end.toDate(zone));
+}
+function reshapeRange(anchor, moving, rules = {}) {
+  const a = parseIsoDay(anchor);
+  const m = parseIsoDay(moving);
+  if (!a || !m) return null;
+  if (rules.allowed && !rules.allowed(m.toString())) return null;
+  const [start, end] = a.compare(m) <= 0 ? [a, m] : [m, a];
+  if (rules.maximumDays && end.compare(start) + 1 > rules.maximumDays) return null;
+  if (rules.unavailable) {
+    for (let d = start; d.compare(end) <= 0; d = d.add({ days: 1 })) {
+      if (rules.unavailable(d.toString())) return null;
+    }
+  }
+  return { start: start.toString(), end: end.toString() };
+}
+export {
+  clampRange,
+  defaultRangePresets,
+  formatRange,
+  normalizeRange,
+  parseIsoDay,
+  reshapeRange,
+  sameRange
+};

package/dist/components/exportData.d.ts

@@ -0,0 +1,58 @@
+export interface CsvColumn<Row> {
+    key: string;
+    /** Header cell. Defaults to the key. */
+    label?: string;
+    /** The value written for a row; the row's `key` field when omitted. */
+    value?: (row: Row) => unknown;
+}
+export interface CsvOptions {
+    /** Field separator. Default ",". Some locales' spreadsheets expect ";". */
+    separator?: string;
+    /** Prefix a UTF-8 byte order mark so Excel reads non-ASCII text correctly. */
+    bom?: boolean;
+    /**
+     * Neutralise cells a spreadsheet would run as a formula (leading = + - @,
+     * tab or CR) by prefixing a quote. On by default: exported data is often
+     * user-supplied, and opening it is enough to trigger a formula.
+     */
+    guardFormulas?: boolean;
+    /** Line ending. Default "\r\n", as RFC 4180 specifies. */
+    newline?: string;
+}
+/** One CSV field, quoted when it holds a separator, a quote or a line break. */
+export declare function csvField(value: unknown, options?: CsvOptions): string;
+/** Rows as CSV text, a header line first. */
+export declare function toCsv<Row>(rows: readonly Row[], columns: readonly CsvColumn<Row>[], options?: CsvOptions): string;
+/**
+ * Hand the viewer a file to save. Does nothing outside a browser, so a call
+ * that runs during SSR is harmless.
+ */
+export declare function downloadFile(name: string, data: Blob | string, type?: string): void;
+/**
+ * A standalone copy of a live SVG: every element carries its computed paint as
+ * an inline style, so CSS custom properties and classes from the page's
+ * stylesheet survive being rendered as an image, and running SMIL animations
+ * are frozen at their end state.
+ */
+export declare function inlineSvg(svg: SVGSVGElement): SVGSVGElement;
+export interface RasterOptions {
+    /** Device pixels per CSS pixel. Default: the screen's ratio, at least 2. */
+    scale?: number;
+    /** Fill behind the drawing; transparent when omitted. */
+    background?: string;
+    /** Extra space around the drawing, in CSS pixels. */
+    padding?: number;
+    /** Drawn above the SVG, in the page's own font. */
+    header?: (ctx: CanvasRenderingContext2D, width: number) => number;
+}
+/** Rasterise an SVG element to a PNG blob with its theme resolved. */
+export declare function svgToPng(svg: SVGSVGElement, options?: RasterOptions): Promise<Blob>;
+/** The first non-transparent background at or above an element. */
+export declare function backgroundOf(el: Element | null): string | undefined;
+/**
+ * A colour as the browser resolves it where `within` sits, for APIs that cannot
+ * read custom properties (canvas, an SVG drawn as an image).
+ */
+export declare function resolveCssColor(value: string, within: Element): string;
+/** A filesystem-safe name from a title. */
+export declare function fileStem(title: string | undefined, fallback: string): string;

package/dist/components/exportData.js

@@ -0,0 +1,165 @@
+const FORMULA_START = /^[=+\-@\t\r]/;
+function cellText(value) {
+  if (value == null) return "";
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function csvField(value, options = {}) {
+  const separator = options.separator ?? ",";
+  let text = cellText(value);
+  if ((options.guardFormulas ?? true) && typeof value === "string" && FORMULA_START.test(text)) {
+    text = `'${text}`;
+  }
+  const needsQuotes = text.includes(separator) || /["\r\n]/.test(text) || /^\s|\s$/.test(text);
+  return needsQuotes ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function toCsv(rows, columns, options = {}) {
+  const separator = options.separator ?? ",";
+  const newline = options.newline ?? "\r\n";
+  const line = (cells) => cells.map((c) => csvField(c, options)).join(separator);
+  const out = [line(columns.map((c) => c.label ?? c.key))];
+  for (const row of rows) {
+    out.push(
+      line(columns.map((c) => c.value ? c.value(row) : row[c.key]))
+    );
+  }
+  return (options.bom ? "\uFEFF" : "") + out.join(newline) + newline;
+}
+function downloadFile(name, data, type = "text/plain;charset=utf-8") {
+  if (typeof document === "undefined" || typeof URL === "undefined") return;
+  const blob = typeof data === "string" ? new Blob([data], { type }) : data;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = name;
+  a.rel = "noopener";
+  a.style.display = "none";
+  document.body.append(a);
+  a.click();
+  a.remove();
+  setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+const PAINT_PROPS = [
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-opacity",
+  "stroke-width",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "opacity",
+  "stop-color",
+  "stop-opacity",
+  "color",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "letter-spacing",
+  "text-anchor",
+  "dominant-baseline",
+  "visibility",
+  "display"
+];
+function inlineSvg(svg) {
+  const clone = svg.cloneNode(true);
+  const source = [svg, ...svg.querySelectorAll("*")];
+  const target = [clone, ...clone.querySelectorAll("*")];
+  source.forEach((el, i) => {
+    const copy = target[i];
+    if (!(copy instanceof Element)) return;
+    const computed = getComputedStyle(el);
+    const style = PAINT_PROPS.map((p) => `${p}:${computed.getPropertyValue(p)}`).filter((d) => !d.endsWith(":")).join(";");
+    copy.setAttribute("style", style);
+    copy.removeAttribute("class");
+  });
+  const comments = document.createTreeWalker(clone, NodeFilter.SHOW_COMMENT);
+  const dead = [];
+  while (comments.nextNode()) dead.push(comments.currentNode);
+  for (const node of dead) node.parentNode?.removeChild(node);
+  for (const anim of clone.querySelectorAll("animate")) {
+    const attr = anim.getAttribute("attributeName");
+    const to = anim.getAttribute("to");
+    if (attr && to != null) anim.parentElement?.setAttribute(attr, to);
+    anim.remove();
+  }
+  clone.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+  const { width, height } = svg.getBoundingClientRect();
+  clone.setAttribute("width", String(width));
+  clone.setAttribute("height", String(height));
+  clone.style.overflow = "visible";
+  return clone;
+}
+async function svgToPng(svg, options = {}) {
+  const copy = inlineSvg(svg);
+  const width = Number(copy.getAttribute("width"));
+  const height = Number(copy.getAttribute("height"));
+  const markup = new XMLSerializer().serializeToString(copy);
+  const url = URL.createObjectURL(new Blob([markup], { type: "image/svg+xml;charset=utf-8" }));
+  try {
+    const img = new Image();
+    img.decoding = "async";
+    const loaded = new Promise((resolve, reject) => {
+      img.onload = () => resolve();
+      img.onerror = () => reject(new Error("SVG could not be rasterised"));
+    });
+    img.src = url;
+    await loaded;
+    const scale = options.scale ?? Math.max(2, globalThis.devicePixelRatio || 1);
+    const pad = options.padding ?? 0;
+    const measure = document.createElement("canvas").getContext("2d");
+    const headerHeight = measure && options.header ? options.header(measure, width) : 0;
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.ceil((width + pad * 2) * scale);
+    canvas.height = Math.ceil((height + headerHeight + pad * 2) * scale);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Canvas 2D is unavailable");
+    ctx.scale(scale, scale);
+    if (options.background) {
+      ctx.fillStyle = options.background;
+      ctx.fillRect(0, 0, width + pad * 2, height + headerHeight + pad * 2);
+    }
+    ctx.translate(pad, pad);
+    if (options.header) options.header(ctx, width);
+    ctx.drawImage(img, 0, headerHeight, width, height);
+    return await new Promise(
+      (resolve, reject) => canvas.toBlob((b) => b ? resolve(b) : reject(new Error("PNG encoding failed")), "image/png")
+    );
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function backgroundOf(el) {
+  for (let node = el; node; node = node.parentElement) {
+    const bg = getComputedStyle(node).backgroundColor;
+    if (bg && bg !== "transparent" && !/rgba\([^)]*,\s*0\)$/.test(bg)) return bg;
+  }
+  return void 0;
+}
+function resolveCssColor(value, within) {
+  if (!value.includes("var(") && !value.toLowerCase().includes("currentcolor")) return value;
+  const probe = document.createElement("span");
+  probe.style.color = value;
+  probe.style.display = "none";
+  within.append(probe);
+  const resolved = getComputedStyle(probe).color;
+  probe.remove();
+  return resolved || value;
+}
+function fileStem(title, fallback) {
+  const stem = (title ?? "").trim().replace(/[\\/:*?"<>|\u0000-\u001f]+/g, "").replace(/\s+/g, "-");
+  return stem || fallback;
+}
+export {
+  backgroundOf,
+  csvField,
+  downloadFile,
+  fileStem,
+  inlineSvg,
+  resolveCssColor,
+  svgToPng,
+  toCsv
+};

package/dist/components/logSearch.d.ts

@@ -0,0 +1,18 @@
+/** The last `max` lines, and how many were cut from the front. */
+export declare function ringWindow<T>(lines: readonly T[], max: number | undefined): {
+    lines: readonly T[];
+    offset: number;
+};
+/** Lines per level, a line with no level counting as `fallback`. */
+export declare function countLevels<L extends string>(lines: readonly {
+    level?: L;
+}[], fallback: L): Map<L, number>;
+/** Case-insensitive substring test; an empty term matches nothing. */
+export declare function matchesTerm(message: string, term: string): boolean;
+/** Positions (into `rows`) of the rows whose message or source holds the term. */
+export declare function matchPositions(rows: readonly {
+    message: string;
+    source?: string;
+}[], term: string): number[];
+/** The next match cursor, wrapping at both ends; -1 when there are none. */
+export declare function stepMatch(current: number, total: number, direction: 1 | -1): number;

package/dist/components/logSearch.js

@@ -0,0 +1,36 @@
+function ringWindow(lines, max) {
+  if (!max || max <= 0 || lines.length <= max) return { lines, offset: 0 };
+  return { lines: lines.slice(lines.length - max), offset: lines.length - max };
+}
+function countLevels(lines, fallback) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const level = line.level ?? fallback;
+    counts.set(level, (counts.get(level) ?? 0) + 1);
+  }
+  return counts;
+}
+function matchesTerm(message, term) {
+  const needle = term.trim().toLowerCase();
+  return needle.length > 0 && message.toLowerCase().includes(needle);
+}
+function matchPositions(rows, term) {
+  if (!term.trim()) return [];
+  const out = [];
+  rows.forEach((row, i) => {
+    if (matchesTerm(row.message, term) || row.source !== void 0 && matchesTerm(row.source, term)) out.push(i);
+  });
+  return out;
+}
+function stepMatch(current, total, direction) {
+  if (total <= 0) return -1;
+  if (current < 0 || current >= total) return direction === 1 ? 0 : total - 1;
+  return (current + direction + total) % total;
+}
+export {
+  countLevels,
+  matchPositions,
+  matchesTerm,
+  ringWindow,
+  stepMatch
+};