@revenexx/studio-shared 0.4.0 → 0.4.2

package/dist/runtime/lib/notice.js

@@ -0,0 +1,19 @@
+const ABBREVIATIONS = /* @__PURE__ */ new Set(["bzw", "usw", "ggf", "inkl", "zzgl", "evtl", "etc", "vgl", "ca", "nr", "max", "min", "abs", "gem", "sog", "e.g", "i.e", "vs"]);
+export function splitNotice(text) {
+  const source = (text ?? "").trim();
+  if (!source) return { title: "", description: null };
+  const pattern = /([.!?])\s+(?=[A-ZÄÖÜ„"(])/g;
+  let match;
+  while (match = pattern.exec(source)) {
+    const end = match.index;
+    if (match[1] === ".") {
+      const word = /([\p{L}.]+)$/u.exec(source.slice(0, end))?.[1] ?? "";
+      const bare = word.replace(/\.$/, "");
+      if (bare.length <= 2 || ABBREVIATIONS.has(bare.toLowerCase())) continue;
+    }
+    const title = source.slice(0, end + 1).trim();
+    const description = source.slice(pattern.lastIndex).trim();
+    return { title, description: description || null };
+  }
+  return { title: source, description: null };
+}

package/dist/runtime/lib/pageSize.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rows per page (PE-1052, Michael 15.10.): 50 by default, 25 / 50 / 100 / 200
+ * to choose from, remembered per user and table. The dummy keeps the choice in
+ * localStorage; the cockpit's `user_preferences` row is where it goes on
+ * transfer (same split as the density toggle).
+ */
+export declare const PAGE_SIZE_OPTIONS: readonly [25, 50, 100, 200];
+export declare const DEFAULT_PAGE_SIZE = 50;
+/** The storage key for one table's page size. */
+export declare function pageSizeStorageKey(table: string): string;
+/** The remembered size for a table, if it is one of the offered sizes. */
+export declare function readPageSize(table: string | null | undefined): number | null;
+export declare function writePageSize(table: string | null | undefined, size: number): void;
+/** The sizes the footer offers — the standard four, plus a surface's own if it set another. */
+export declare function pageSizeOptions(current: number): number[];

package/dist/runtime/lib/pageSize.js

@@ -0,0 +1,26 @@
+export const PAGE_SIZE_OPTIONS = [25, 50, 100, 200];
+export const DEFAULT_PAGE_SIZE = 50;
+export function pageSizeStorageKey(table) {
+  return `cockpit.datatable.pageSize:${table}`;
+}
+export function readPageSize(table) {
+  if (!table) return null;
+  try {
+    if (typeof window === "undefined") return null;
+    const n = Number(window.localStorage.getItem(pageSizeStorageKey(table)));
+    return PAGE_SIZE_OPTIONS.includes(n) ? n : null;
+  } catch {
+    return null;
+  }
+}
+export function writePageSize(table, size) {
+  if (!table) return;
+  try {
+    if (typeof window === "undefined") return;
+    window.localStorage.setItem(pageSizeStorageKey(table), String(size));
+  } catch {
+  }
+}
+export function pageSizeOptions(current) {
+  return [.../* @__PURE__ */ new Set([...PAGE_SIZE_OPTIONS, current])].sort((a, b) => a - b);
+}

package/dist/runtime/lib/sidebarAreas.d.ts

@@ -0,0 +1,46 @@
+import type { SidebarNavSection } from '../types/nav.js';
+/**
+ * Area mode of the studio sidebar (Commerce Studio, click dummy variant C3).
+ *
+ * The section the route is in shows its rows as before. Every other section
+ * shrinks to a single "area" row; resting on it (or
+ * clicking it) lays a panel with that section's rows next to the sidebar.
+ * Nothing folds: which section is open follows the route, not a toggle.
+ */
+export type SidebarAreaBlock = {
+    kind: 'section';
+    section: SidebarNavSection;
+} | {
+    kind: 'area';
+    section: SidebarNavSection;
+};
+/** True when one of the section's rows (or their tabs) holds `path`. */
+export declare function sectionHoldsActive(section: SidebarNavSection, path: string, best?: number): boolean;
+/**
+ * A section whose one entry carries the section's own name (Konfiguration →
+ * Konfiguration) is that entry: a plain link row, never an area with a panel
+ * of one (Michael 17.10.).
+ */
+export declare function isSelfNamed(section: SidebarNavSection): boolean;
+/**
+ * Which sections render as rows and which as area rows. Only a section without
+ * a label (the pinned Dashboard row) and the route's own section show rows;
+ * a one-row section is an area too, so every section reads the same way
+ * (Michael 17.10.). With `best`, only the section of the closest match opens.
+ */
+export declare function sidebarAreaBlocks(sections: SidebarNavSection[], path: string, best?: number): SidebarAreaBlock[];
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Safe triangle: is `p` inside the triangle spanned by where the pointer last
+ * rested on the open area row (`apex`) and the panel's near edge (`top`,
+ * `bottom`)? Then the pointer is on its way into the panel and crossing other
+ * area rows must not switch the panel (Tog's Apple menus, Amazon's menu-aim).
+ */
+export declare function inSafeTriangle(p: Point, apex: Point, top: Point, bottom: Point): boolean;
+/** Timings, in ms. Opening waits for a rest; switching an open panel does not. */
+export declare const AREA_OPEN_DELAY = 150;
+export declare const AREA_AIM_DELAY = 180;
+export declare const AREA_CLOSE_DELAY = 300;

package/dist/runtime/lib/sidebarAreas.js

@@ -0,0 +1,25 @@
+import { sidebarItemHoldsActive, sidebarItemMatchLength } from "./sidebarNav.js";
+export function sectionHoldsActive(section, path, best) {
+  if (best === void 0) return section.items.some((item) => sidebarItemHoldsActive(item, path));
+  return best >= 0 && section.items.some((item) => sidebarItemMatchLength(item, path) === best);
+}
+export function isSelfNamed(section) {
+  return section.items.length === 1 && section.items[0].label === section.label;
+}
+export function sidebarAreaBlocks(sections, path, best) {
+  return sections.map(
+    (section) => !section.label || isSelfNamed(section) || sectionHoldsActive(section, path, best) ? { kind: "section", section } : { kind: "area", section }
+  );
+}
+export function inSafeTriangle(p, apex, top, bottom) {
+  const side = (a, b, c) => (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y);
+  const d1 = side(p, apex, top);
+  const d2 = side(p, top, bottom);
+  const d3 = side(p, bottom, apex);
+  const neg = d1 < 0 || d2 < 0 || d3 < 0;
+  const pos = d1 > 0 || d2 > 0 || d3 > 0;
+  return !(neg && pos);
+}
+export const AREA_OPEN_DELAY = 150;
+export const AREA_AIM_DELAY = 180;
+export const AREA_CLOSE_DELAY = 300;

package/dist/runtime/lib/sidebarNav.d.ts

@@ -1,3 +1,4 @@
+import type { InjectionKey, Ref } from 'vue';
 import type { SidebarNavItem } from '../types/nav.js';
 /**
  * Pure helpers behind `SidebarNav` / `SidebarNavLink`. They live outside the
@@ -12,16 +13,34 @@ import type { SidebarNavItem } from '../types/nav.js';
  */
 /** Stable identity for `v-for` keys — `to` is unique where it exists. */
 export declare function sidebarItemKey(item: SidebarNavItem): string;
-/** True when `path` is the item's own route, or sits below it. */
+/**
+ * True when `path` is the item's own route, or sits below it. `path` may carry
+ * a query: an item whose `to` names one (`/configuration?tab=markets`) is the
+ * page with exactly those parameters (an empty value: the parameter is
+ * absent); every other item ignores the query.
+ */
 export declare function sidebarItemIsActive(item: SidebarNavItem, path: string): boolean;
 /** True when the item, or any of its tabs, matches `path`. */
 export declare function sidebarItemHoldsActive(item: SidebarNavItem, path: string): boolean;
+/**
+ * How closely the item (or one of its tabs) matches `path`: the length of the
+ * longest matching route, -1 when none does. Two rows can both hold a path —
+ * Konfiguration's Zahlung owns `/payments/providers`, Auftragsabwicklung's
+ * Zahlungen owns `/payments` — and only the closer one is where you are.
+ */
+export declare function sidebarItemMatchLength(item: SidebarNavItem, path: string): number;
+/** The closest match any row of the sidebar has for `path` (-1: none). */
+export declare function sidebarBestMatch(sections: ReadonlyArray<{
+    items: SidebarNavItem[];
+}>, path: string): number;
+/** Injected by `SidebarNav`: the closest match of the whole sidebar for the route. */
+export declare const SIDEBAR_BEST_MATCH: InjectionKey<Ref<number>>;
 /**
  * Which row gets the highlight. The tabs of a group are not rows of their own,
  * so the group stays lit for every one of them — an operator on *Carriers*
  * still sees where they are, which is **Shipping**.
  */
-export declare function sidebarItemIsCurrent(item: SidebarNavItem, path: string): boolean;
+export declare function sidebarItemIsCurrent(item: SidebarNavItem, path: string, best?: number): boolean;
 /**
  * Where the row links. A group with a route of its own opens that (it is the
  * default tab); a pure container — a heading several apps contribute to, where
@@ -32,3 +51,21 @@ export declare function sidebarItemIsCurrent(item: SidebarNavItem, path: string)
  * section (Settings, Apps, …) from rendering a dead row.
  */
 export declare function sidebarItemTarget(item: SidebarNavItem): string | undefined;
+/** A box on screen, as `getBoundingClientRect` reports it — only what the sum needs. */
+interface VerticalBox {
+    top: number;
+    height: number;
+}
+/**
+ * Where the sidebar's scroller has to stand for the current row to be in sight,
+ * moving as little as possible: the row's top edge when it sits above the view,
+ * its bottom edge when below, and nowhere when it is already visible.
+ *
+ * This is `scrollIntoView({ block: 'nearest' })` done by hand. The call itself is
+ * not usable here: Chrome also moves the point the next Tab starts from to the row
+ * it scrolled to, so after a page load the first Tab skipped the host's
+ * *Skip to content* and everything before the current row (IN-55). Setting the
+ * scroller's `scrollTop` moves the list and leaves the keyboard where it was.
+ */
+export declare function sidebarRevealScrollTop(view: VerticalBox, row: VerticalBox, scrollTop: number): number;
+export {};

package/dist/runtime/lib/sidebarNav.js

@@ -3,14 +3,33 @@ export function sidebarItemKey(item) {
 }
 export function sidebarItemIsActive(item, path) {
   if (!item.to) return false;
-  if (item.exact) return path === item.to;
-  return path === item.to || path.startsWith(`${item.to}/`);
+  const [bare, query = ""] = path.split("?");
+  const [to, wanted] = item.to.split("?");
+  if (wanted !== void 0) {
+    const have = new URLSearchParams(query);
+    return bare === to && [...new URLSearchParams(wanted)].every(([k, v]) => (have.get(k) ?? "") === v);
+  }
+  if (item.exact) return bare === to;
+  return bare === to || bare.startsWith(`${to}/`);
 }
 export function sidebarItemHoldsActive(item, path) {
   return sidebarItemIsActive(item, path) || (item.children ?? []).some((child) => sidebarItemHoldsActive(child, path));
 }
-export function sidebarItemIsCurrent(item, path) {
-  return sidebarItemHoldsActive(item, path);
+export function sidebarItemMatchLength(item, path) {
+  const own = sidebarItemIsActive(item, path) ? item.to.length + 0.5 : -1;
+  return Math.max(own, ...(item.children ?? []).map((child) => tabMatchLength(child, path)));
+}
+function tabMatchLength(item, path) {
+  const own = sidebarItemIsActive(item, path) ? item.to.length : -1;
+  return Math.max(own, ...(item.children ?? []).map((child) => tabMatchLength(child, path)));
+}
+export function sidebarBestMatch(sections, path) {
+  return Math.max(-1, ...sections.flatMap((section) => section.items.map((item) => sidebarItemMatchLength(item, path))));
+}
+export const SIDEBAR_BEST_MATCH = Symbol("sidebar-best-match");
+export function sidebarItemIsCurrent(item, path, best) {
+  if (best === void 0) return sidebarItemHoldsActive(item, path);
+  return best >= 0 && sidebarItemMatchLength(item, path) === best;
 }
 export function sidebarItemTarget(item) {
   if (item.to) return item.to;
@@ -20,3 +39,10 @@ export function sidebarItemTarget(item) {
   }
   return void 0;
 }
+export function sidebarRevealScrollTop(view, row, scrollTop) {
+  const top = row.top - view.top + scrollTop;
+  const bottom = top + row.height;
+  if (top < scrollTop) return top;
+  if (bottom > scrollTop + view.height) return Math.min(top, bottom - view.height);
+  return scrollTop;
+}

package/dist/runtime/lib/solarIconMap.d.ts

@@ -3,11 +3,12 @@
  *
  * The closed set of Solar icons the cockpit resolves by name: every icon the
  * app manifests, this repo's code and the curated picker set ask for. Named
- * imports, so the bundle carries these 127 instead of all 1,413
+ * imports, so the bundle carries these 150 instead of all 1,413
  * (PE-985). A name outside the set renders the fallback glyph; run
  * `pnpm icons` after adding one, and `pnpm icons:check` to verify.
  */
 import type { Component } from 'vue';
+import { Record } from '#solar-icons';
 export declare const SOLAR_ICON_MAP: Readonly<Record<string, Component>>;
 /** Manifest names Solar does not have → the glyph drawn for them. */
 export declare const SOLAR_ICON_ALIASES: Readonly<Record<string, string>>;

package/dist/runtime/lib/solarIconMap.js

@@ -3,6 +3,7 @@ import {
   AddSquare,
   Alarm,
   Archive,
+  ArrowLeft,
   ArrowRight,
   Atom,
   Backspace,
@@ -16,13 +17,15 @@ import {
   Bookmark,
   Box,
   BranchingPathsUp,
-  Broom,
   Buildings,
+  Calculator,
   Calendar,
+  CalendarAdd,
+  CalendarMark,
   CalendarMinimalistic,
   Card,
-  CardTransfer,
   Cart,
+  CartCheck,
   CartLarge,
   CartPlus,
   Chart,
@@ -32,6 +35,7 @@ import {
   ChatRoundLine,
   CheckCircle,
   CheckRead,
+  CheckSquare,
   ChecklistMinimalistic,
   Clipboard,
   ClipboardList,
@@ -48,9 +52,11 @@ import {
   Download,
   DownloadMinimalistic,
   Earth,
+  Euro,
   Eye,
   File,
   FileText,
+  Flag,
   Folder,
   FolderOpen,
   FolderPathConnect,
@@ -64,6 +70,7 @@ import {
   Heart,
   Help,
   Home,
+  Hourglass,
   Import,
   Inbox,
   InboxIn,
@@ -72,12 +79,17 @@ import {
   Letter,
   Lightbulb,
   Link,
+  LinkBroken,
+  LinkBrokenMinimalistic,
   LinkRound,
   List,
   ListCheck,
   Lock,
+  LockKeyhole,
+  Logout,
   MagicStick,
   Magnifer,
+  Mailbox,
   Map,
   MapPoint,
   MedalRibbon,
@@ -92,6 +104,7 @@ import {
   PlugCircle,
   Pulse,
   Radar,
+  Record,
   Refresh,
   RefreshCircle,
   Restart,
@@ -107,20 +120,30 @@ import {
   ShieldUser,
   Shop,
   Shuffle,
+  Snowflake,
   Star,
   Stars,
+  StopCircle,
   Tag,
   TagPrice,
+  TextField,
   Ticket,
+  TransferHorizontal,
   TrashBinMinimalistic,
   TrashBinTrash,
+  UndoLeft,
   UndoLeftRound,
   Upload,
   User,
   UserBlock,
   UserCheck,
+  UserCrossRounded,
+  UserHandUp,
   UserId,
+  UserPlus,
+  UserPlusRounded,
   UsersGroupRounded,
+  UsersGroupTwoRounded,
   Wallet,
   WalletMoney,
   Weigher,
@@ -132,6 +155,7 @@ export const SOLAR_ICON_MAP = {
   AddSquare,
   Alarm,
   Archive,
+  ArrowLeft,
   ArrowRight,
   Atom,
   Backspace,
@@ -145,13 +169,15 @@ export const SOLAR_ICON_MAP = {
   Bookmark,
   Box,
   BranchingPathsUp,
-  Broom,
   Buildings,
+  Calculator,
   Calendar,
+  CalendarAdd,
+  CalendarMark,
   CalendarMinimalistic,
   Card,
-  CardTransfer,
   Cart,
+  CartCheck,
   CartLarge,
   CartPlus,
   Chart,
@@ -161,6 +187,7 @@ export const SOLAR_ICON_MAP = {
   ChatRoundLine,
   CheckCircle,
   CheckRead,
+  CheckSquare,
   ChecklistMinimalistic,
   Clipboard,
   ClipboardList,
@@ -177,9 +204,11 @@ export const SOLAR_ICON_MAP = {
   Download,
   DownloadMinimalistic,
   Earth,
+  Euro,
   Eye,
   File,
   FileText,
+  Flag,
   Folder,
   FolderOpen,
   FolderPathConnect,
@@ -193,6 +222,7 @@ export const SOLAR_ICON_MAP = {
   Heart,
   Help,
   Home,
+  Hourglass,
   Import,
   Inbox,
   InboxIn,
@@ -201,12 +231,17 @@ export const SOLAR_ICON_MAP = {
   Letter,
   Lightbulb,
   Link,
+  LinkBroken,
+  LinkBrokenMinimalistic,
   LinkRound,
   List,
   ListCheck,
   Lock,
+  LockKeyhole,
+  Logout,
   MagicStick,
   Magnifer,
+  Mailbox,
   Map,
   MapPoint,
   MedalRibbon,
@@ -221,6 +256,7 @@ export const SOLAR_ICON_MAP = {
   PlugCircle,
   Pulse,
   Radar,
+  Record,
   Refresh,
   RefreshCircle,
   Restart,
@@ -236,20 +272,30 @@ export const SOLAR_ICON_MAP = {
   ShieldUser,
   Shop,
   Shuffle,
+  Snowflake,
   Star,
   Stars,
+  StopCircle,
   Tag,
   TagPrice,
+  TextField,
   Ticket,
+  TransferHorizontal,
   TrashBinMinimalistic,
   TrashBinTrash,
+  UndoLeft,
   UndoLeftRound,
   Upload,
   User,
   UserBlock,
   UserCheck,
+  UserCrossRounded,
+  UserHandUp,
   UserId,
+  UserPlus,
+  UserPlusRounded,
   UsersGroupRounded,
+  UsersGroupTwoRounded,
   Wallet,
   WalletMoney,
   Weigher,

package/dist/runtime/lib/swipeToClose.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Swipe down to close a bottom sheet on the phone (Charge 2, Michael 12.10.).
+ *
+ * `v-swipe-close="close"` on any element inside a sheet: the sheet (the
+ * element marked `data-swipe-sheet`, else the nearest `role="dialog"`, else
+ * the element itself) follows the finger downwards; released past a quarter of
+ * its height — or flicked — it slides out and `close` runs, otherwise it snaps
+ * back. A drag only starts while the scroller under the finger is at its top,
+ * so it never fights the sheet's own scrolling. Phone widths only; on a wider
+ * screen the listeners do nothing.
+ */
+import type { Directive } from 'vue';
+export interface SwipeState {
+    cleanup: () => void;
+}
+/** Pure decision, exported for tests: does a drag of `dy` px in `ms` close? */
+export declare function shouldClose(dy: number, ms: number, height: number): boolean;
+export declare function attachSwipeToClose(el: HTMLElement, onClose: () => void): SwipeState;
+type SwipeEl = HTMLElement & {
+    __swipeClose?: SwipeState;
+    __swipeHandler?: () => void;
+};
+/** `v-swipe-close="handler"` — see the module comment. */
+export declare const vSwipeClose: Directive<SwipeEl, (() => void) | undefined>;
+export {};

package/dist/runtime/lib/swipeToClose.js

@@ -0,0 +1,118 @@
+const PHONE = "(max-width: 767.98px)";
+const CLOSE_RATIO = 0.25;
+const FLICK_VELOCITY = 0.6;
+function sheetOf(el) {
+  return el.closest("[data-swipe-sheet]") ?? el.closest('[role="dialog"]') ?? el;
+}
+function scrollerAt(target, sheet) {
+  let node = target instanceof HTMLElement ? target : null;
+  while (node) {
+    const style = getComputedStyle(node);
+    if (/(auto|scroll)/.test(style.overflowY) && node.scrollHeight > node.clientHeight) return node;
+    if (node === sheet) break;
+    node = node.parentElement;
+  }
+  return null;
+}
+export function shouldClose(dy, ms, height) {
+  if (dy <= 0) return false;
+  if (dy > height * CLOSE_RATIO) return true;
+  return ms > 0 && dy / ms > FLICK_VELOCITY && dy > 24;
+}
+export function attachSwipeToClose(el, onClose) {
+  let sheet = null;
+  let startY = 0;
+  let startT = 0;
+  let dy = 0;
+  let dragging = false;
+  let armed = false;
+  const reset = (animate) => {
+    if (!sheet) return;
+    sheet.style.transition = animate ? "transform 200ms ease-out" : "";
+    sheet.style.transform = "";
+  };
+  const onStart = (e) => {
+    if (!window.matchMedia(PHONE).matches || e.touches.length !== 1) return;
+    sheet = sheetOf(el);
+    const scroller = scrollerAt(e.target, sheet);
+    armed = !scroller || scroller.scrollTop <= 0;
+    if (!armed) return;
+    startY = e.touches[0].clientY;
+    startT = performance.now();
+    dy = 0;
+    dragging = false;
+  };
+  const onMove = (e) => {
+    if (!armed || !sheet) return;
+    const delta = e.touches[0].clientY - startY;
+    if (!dragging) {
+      if (delta < 6) {
+        if (delta < -6) armed = false;
+        return;
+      }
+      dragging = true;
+      sheet.style.transition = "none";
+    }
+    dy = Math.max(0, delta);
+    sheet.style.transform = `translateY(${dy}px)`;
+    if (e.cancelable) e.preventDefault();
+  };
+  const onEnd = () => {
+    if (!armed || !sheet || !dragging) {
+      armed = false;
+      return;
+    }
+    armed = false;
+    dragging = false;
+    const height = sheet.getBoundingClientRect().height || window.innerHeight;
+    if (shouldClose(dy, performance.now() - startT, height)) {
+      const s = sheet;
+      s.style.transition = "transform 180ms ease-in";
+      s.style.transform = "translateY(100%)";
+      window.setTimeout(() => {
+        onClose();
+        window.setTimeout(() => {
+          s.style.transition = "";
+          s.style.transform = "";
+        }, 350);
+      }, 170);
+    } else {
+      reset(true);
+    }
+  };
+  const host = () => sheetOf(el);
+  let bound = null;
+  const bind = () => {
+    bound = host();
+    bound.addEventListener("touchstart", onStart, { passive: true });
+    bound.addEventListener("touchmove", onMove, { passive: false });
+    bound.addEventListener("touchend", onEnd);
+    bound.addEventListener("touchcancel", onEnd);
+  };
+  bind();
+  return {
+    cleanup() {
+      if (!bound) return;
+      bound.removeEventListener("touchstart", onStart);
+      bound.removeEventListener("touchmove", onMove);
+      bound.removeEventListener("touchend", onEnd);
+      bound.removeEventListener("touchcancel", onEnd);
+      bound = null;
+    }
+  };
+}
+export const vSwipeClose = {
+  mounted(el, binding) {
+    el.__swipeHandler = binding.value;
+    requestAnimationFrame(() => {
+      el.__swipeClose = attachSwipeToClose(el, () => el.__swipeHandler?.());
+    });
+  },
+  updated(el, binding) {
+    el.__swipeHandler = binding.value;
+  },
+  beforeUnmount(el) {
+    el.__swipeClose?.cleanup();
+    delete el.__swipeClose;
+  }
+};

package/dist/runtime/lib/tableExport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * XLSX and CSV writer for the list export (PE-1052, Michael 15.10.). Used where
+ * the app declares no Baseline IO export: the header's and the bulk bar's
+ * „Exportieren“ then write the file here — current view, all, or the
+ * selection, the visible columns in their order.
+ *
+ * No dependency. XLSX is a zip of five small XML files; a stored (uncompressed)
+ * zip is a valid one, and every spreadsheet program reads it. Pulling SheetJS
+ * into the shared package for one sheet of text would add 400 KB to every host
+ * that renders a DataTable.
+ */
+export type ExportCell = string | number | null | undefined;
+export interface ExportSheet {
+    headers: string[];
+    rows: ExportCell[][];
+    /** Sheet tab name, cut to Excel's 31 characters. */
+    sheetName?: string;
+}
+/**
+ * Semicolon-separated with a UTF-8 BOM: what German Excel opens by double
+ * click with umlauts and decimal commas intact. A comma-separated file opens
+ * there as one column.
+ */
+export declare function toCsv(sheet: ExportSheet, sep?: string): string;
+/** A1-style column letters: 0 → A, 25 → Z, 26 → AA. */
+export declare function columnLetter(index: number): string;
+export declare function crc32(bytes: Uint8Array): number;
+export declare function toXlsx(sheet: ExportSheet): Uint8Array;
+/** „Produkte 2026-10-15“ → `Produkte-2026-10-15`: safe on every file system. */
+export declare function exportFileName(base: string, ext: 'csv' | 'xlsx', now?: Date): string;
+export declare function downloadExport(sheet: ExportSheet, format: 'csv' | 'xlsx', fileBase: string): void;