@eifi1/ui-kit 0.4.0

package/dist/lib/calc.js

@@ -0,0 +1,180 @@
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === " ") {
+      i++;
+      continue;
+    }
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/") {
+      tokens.push({ kind: "op", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ kind: "lparen" });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ kind: "rparen" });
+      i++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === ".") {
+      let j = i;
+      let dotSeen = false;
+      while (j < input.length && (input[j] >= "0" && input[j] <= "9" || input[j] === ".")) {
+        if (input[j] === ".") {
+          if (dotSeen) return null;
+          dotSeen = true;
+        }
+        j++;
+      }
+      const num = Number(input.slice(i, j));
+      if (!Number.isFinite(num)) return null;
+      tokens.push({ kind: "num", value: num });
+      i = j;
+      continue;
+    }
+    return null;
+  }
+  return tokens;
+}
+function parse(tokens) {
+  let pos = 0;
+  function parseExpr() {
+    let value = parseTerm();
+    if (value === null) return null;
+    while (pos < tokens.length) {
+      const tok = tokens[pos];
+      if (tok.kind === "op" && (tok.value === "+" || tok.value === "-")) {
+        pos++;
+        const rhs = parseTerm();
+        if (rhs === null) return null;
+        value = tok.value === "+" ? value + rhs : value - rhs;
+      } else break;
+    }
+    return value;
+  }
+  function parseTerm() {
+    let value = parseFactor();
+    if (value === null) return null;
+    while (pos < tokens.length) {
+      const tok = tokens[pos];
+      if (tok.kind === "op" && (tok.value === "*" || tok.value === "/")) {
+        pos++;
+        const rhs = parseFactor();
+        if (rhs === null) return null;
+        if (tok.value === "/") {
+          if (rhs === 0) return null;
+          value = value / rhs;
+        } else {
+          value = value * rhs;
+        }
+      } else break;
+    }
+    return value;
+  }
+  function parseFactor() {
+    const tok = tokens[pos];
+    if (!tok) return null;
+    if (tok.kind === "op" && (tok.value === "+" || tok.value === "-")) {
+      pos++;
+      const operand = parseFactor();
+      if (operand === null) return null;
+      return tok.value === "-" ? -operand : operand;
+    }
+    if (tok.kind === "lparen") {
+      pos++;
+      const inner = parseExpr();
+      if (inner === null) return null;
+      if (tokens[pos]?.kind !== "rparen") return null;
+      pos++;
+      return inner;
+    }
+    if (tok.kind === "num") {
+      pos++;
+      return tok.value;
+    }
+    return null;
+  }
+  const result = parseExpr();
+  if (result === null) return null;
+  if (pos !== tokens.length) return null;
+  return result;
+}
+function evaluateExpression(expr) {
+  const normalized = expr.replace(/×/g, "*").replace(/÷/g, "/").replace(/[−–—]/g, "-").replace(/,/g, ".").trim();
+  if (normalized === "") return null;
+  const tokens = tokenize(normalized);
+  if (tokens === null || tokens.length === 0) return null;
+  const result = parse(tokens);
+  if (result === null || !Number.isFinite(result)) return null;
+  return result;
+}
+function looksLikeExpression(s) {
+  const t = s.trim();
+  if (t === "") return false;
+  if (/^-?\d*[.,]?\d*$/.test(t)) return false;
+  return /[+\-*/×÷−–—()]/.test(t.replace(/^-/, ""));
+}
+function formatResult(n) {
+  if (!Number.isFinite(n)) return "";
+  if (Math.abs(n) >= 1e21) return BigInt(n).toString();
+  return trimTrailingZeros(n.toFixed(10));
+}
+function trimTrailingZeros(fixed) {
+  if (!fixed.includes(".")) return fixed;
+  const trimmed = fixed.replace(/0+$/, "").replace(/\.$/, "");
+  return trimmed === "-0" || trimmed === "" ? "0" : trimmed;
+}
+function commitExpression(raw) {
+  const s = raw.trim();
+  if (looksLikeExpression(s)) {
+    const n = evaluateExpression(s);
+    if (n !== null) return formatResult(n);
+  }
+  const cleaned = s.replace(/,/g, ".").replace(/[^0-9.-]/g, "").replace(/(?!^)-/g, "");
+  return cleaned.replace(/^(-?\d*\.?\d*).*$/, "$1");
+}
+function sanitizeLive(raw) {
+  return dropExtraDots(raw.replace(/,/g, ".").replace(/[^0-9.+\-*/×÷()]/g, ""));
+}
+function dropExtraDots(s) {
+  let out = "";
+  let dotInNumber = false;
+  for (const ch of s) {
+    if (ch === ".") {
+      if (dotInNumber) continue;
+      dotInNumber = true;
+    } else if (ch < "0" || ch > "9") {
+      dotInNumber = false;
+    }
+    out += ch;
+  }
+  return out;
+}
+function isBareAmount(s) {
+  const t = s.trim();
+  return t !== "" && /^\d*[.,]?\d*$/.test(t);
+}
+function splitLeadingSign(text) {
+  const trimmed = text.trimStart();
+  const sign = trimmed.charAt(0);
+  if (sign !== "-" && sign !== "+") return { sign: "", rest: text };
+  const rest = trimmed.slice(1);
+  if (rest !== "" && !isBareAmount(rest)) return { sign: "", rest: text };
+  return { sign, rest };
+}
+export {
+  commitExpression,
+  evaluateExpression,
+  formatResult,
+  isBareAmount,
+  looksLikeExpression,
+  sanitizeLive,
+  splitLeadingSign
+};
+//# sourceMappingURL=calc.js.map

package/dist/lib/calc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/calc.ts"],"sourcesContent":["/**\n * A tiny, dependency-free arithmetic evaluator for the numeric input fields.\n * It lets users type a calculation (e.g. \"12.50+3.20\" or \"100/3\") straight into\n * an amount field, or build one in the calculator popover, and have it resolve\n * to a number. Deliberately NOT backed by `eval`/`Function` — it's a hand-rolled\n * tokenizer + recursive-descent parser over a closed grammar (digits, decimals,\n * `+ - * /`, unary minus, parentheses), so no arbitrary code can run.\n */\n\ntype Token =\n  | { kind: \"num\"; value: number }\n  | { kind: \"op\"; value: \"+\" | \"-\" | \"*\" | \"/\" }\n  | { kind: \"lparen\" }\n  | { kind: \"rparen\" };\n\nfunction tokenize(input: string): Token[] | null {\n  const tokens: Token[] = [];\n  let i = 0;\n  while (i < input.length) {\n    const ch = input[i];\n    if (ch === \" \") {\n      i++;\n      continue;\n    }\n    if (ch === \"+\" || ch === \"-\" || ch === \"*\" || ch === \"/\") {\n      tokens.push({ kind: \"op\", value: ch });\n      i++;\n      continue;\n    }\n    if (ch === \"(\") {\n      tokens.push({ kind: \"lparen\" });\n      i++;\n      continue;\n    }\n    if (ch === \")\") {\n      tokens.push({ kind: \"rparen\" });\n      i++;\n      continue;\n    }\n    if ((ch >= \"0\" && ch <= \"9\") || ch === \".\") {\n      let j = i;\n      let dotSeen = false;\n      while (j < input.length && ((input[j] >= \"0\" && input[j] <= \"9\") || input[j] === \".\")) {\n        if (input[j] === \".\") {\n          if (dotSeen) return null; // two dots in one number → invalid\n          dotSeen = true;\n        }\n        j++;\n      }\n      const num = Number(input.slice(i, j));\n      if (!Number.isFinite(num)) return null;\n      tokens.push({ kind: \"num\", value: num });\n      i = j;\n      continue;\n    }\n    return null; // unknown character\n  }\n  return tokens;\n}\n\n/**\n * Recursive-descent parse honouring `* /` over `+ -` and left-associativity.\n * Returns `null` for any malformed input (the `null` sentinel is safe because a\n * valid result of 0 is distinct from it). Division by zero is treated as invalid.\n *\n *   expr   := term (('+' | '-') term)*\n *   term   := factor (('*' | '/') factor)*\n *   factor := ('+' | '-') factor | number | '(' expr ')'\n */\nfunction parse(tokens: Token[]): number | null {\n  let pos = 0;\n\n  function parseExpr(): number | null {\n    let value = parseTerm();\n    if (value === null) return null;\n    while (pos < tokens.length) {\n      const tok = tokens[pos];\n      if (tok.kind === \"op\" && (tok.value === \"+\" || tok.value === \"-\")) {\n        pos++;\n        const rhs = parseTerm();\n        if (rhs === null) return null;\n        value = tok.value === \"+\" ? value + rhs : value - rhs;\n      } else break;\n    }\n    return value;\n  }\n\n  function parseTerm(): number | null {\n    let value = parseFactor();\n    if (value === null) return null;\n    while (pos < tokens.length) {\n      const tok = tokens[pos];\n      if (tok.kind === \"op\" && (tok.value === \"*\" || tok.value === \"/\")) {\n        pos++;\n        const rhs = parseFactor();\n        if (rhs === null) return null;\n        if (tok.value === \"/\") {\n          if (rhs === 0) return null;\n          value = value / rhs;\n        } else {\n          value = value * rhs;\n        }\n      } else break;\n    }\n    return value;\n  }\n\n  function parseFactor(): number | null {\n    const tok = tokens[pos];\n    if (!tok) return null;\n    if (tok.kind === \"op\" && (tok.value === \"+\" || tok.value === \"-\")) {\n      pos++;\n      const operand = parseFactor();\n      if (operand === null) return null;\n      return tok.value === \"-\" ? -operand : operand;\n    }\n    if (tok.kind === \"lparen\") {\n      pos++;\n      const inner = parseExpr();\n      if (inner === null) return null;\n      if (tokens[pos]?.kind !== \"rparen\") return null;\n      pos++;\n      return inner;\n    }\n    if (tok.kind === \"num\") {\n      pos++;\n      return tok.value;\n    }\n    return null;\n  }\n\n  const result = parseExpr();\n  if (result === null) return null;\n  if (pos !== tokens.length) return null; // leftover tokens → invalid\n  return result;\n}\n\n/** Evaluate an arithmetic string, returning `null` if it isn't a valid sum.\n * Accepts the on-screen operator glyphs (`× ÷ −`) and comma decimals too. */\nexport function evaluateExpression(expr: string): number | null {\n  const normalized = expr\n    .replace(/×/g, \"*\")\n    .replace(/÷/g, \"/\")\n    .replace(/[−–—]/g, \"-\") // unicode minus / en / em dash → ascii\n    .replace(/,/g, \".\")\n    .trim();\n  if (normalized === \"\") return null;\n  const tokens = tokenize(normalized);\n  if (tokens === null || tokens.length === 0) return null;\n  const result = parse(tokens);\n  if (result === null || !Number.isFinite(result)) return null;\n  return result;\n}\n\n/** True when `s` carries arithmetic beyond a single leading minus — i.e. a plain\n * number (or a lone negative like \"-5\") is NOT an expression, but \"12+5\" is.\n * Used to decide whether a field's text should be evaluated on commit.\n *\n * The operator set is the one {@link evaluateExpression} accepts, on-screen glyphs\n * included: the calculator keypad inserts `× ÷ −`, and a `−` that this said was not\n * arithmetic went on to be read as a plain number — where the digits-only fallback\n * in {@link commitExpression} silently ate it, turning \"-42−−50\" (= 8) into a bare\n * 8 with no record that a sum had happened at all. */\nexport function looksLikeExpression(s: string): boolean {\n  const t = s.trim();\n  if (t === \"\") return false;\n  if (/^-?\\d*[.,]?\\d*$/.test(t)) return false; // plain (optionally negative) decimal\n  return /[+\\-*/×÷−–—()]/.test(t.replace(/^-/, \"\"));\n}\n\n/** Render an evaluated number back to a field-friendly string, trimming binary\n * float noise (so 0.1 + 0.2 reads \"0.3\", not \"0.30000000000000004\").\n *\n * FIXED notation, always, and that is the whole point of the function rather than a\n * detail of it. This used to end in `parseFloat(n.toFixed(10)).toString()`, and\n * `Number.prototype.toString` switches to EXPONENT notation below 1e-6 and at or\n * above 1e21 — an alphabet containing `e`, `+` and `-`. Neither function that reads a\n * field's text back accepts it: {@link tokenize} rejects `e` as an unknown character\n * and {@link sanitizeLive} deletes it. So {@link commitExpression} fell through to\n * its digits-only cleanup, which stripped the `e` and CONCATENATED the mantissa to\n * the exponent. A field committed its own output as a different number:\n *\n *     \"1/10000000\"                -> \"1e-7\"               -> \"17\"   (AmountInput: \"6\")\n *     \"999999999999*999999999999\" -> \"9.99999999998e+23\"  -> \"9.9999999999823\"\n *\n * Both controls commit on blur AND on Enter, so Enter-then-click-away was enough on\n * its own, it was silent, and it was in a money field.\n *\n * The invariant, which the test asserts directly rather than by example:\n * **`commitExpression(formatResult(n))` equals `formatResult(n)` for every finite\n * `n`.** Anything rendered here has to survive being read back. */\nexport function formatResult(n: number): string {\n  if (!Number.isFinite(n)) return \"\";\n  // At or above 1e21 `toFixed` gives up and hands back `toString`'s exponent form —\n  // but every double that large is an integer, so BigInt renders it exactly.\n  if (Math.abs(n) >= 1e21) return BigInt(n).toString();\n  return trimTrailingZeros(n.toFixed(10));\n}\n\n/** \"15.7000000000\" -> \"15.7\", \"0.0000000000\" -> \"0\". The ten decimals are where the\n *  binary float noise gets rounded off; this is only about not showing the padding. */\nfunction trimTrailingZeros(fixed: string): string {\n  if (!fixed.includes(\".\")) return fixed;\n  const trimmed = fixed.replace(/0+$/, \"\").replace(/\\.$/, \"\");\n  // `toFixed` keeps the sign on a magnitude that rounded away to nothing\n  // (\"-0.0000000000\"); `toString` did not, and \"-0\" in an amount field is noise.\n  return trimmed === \"-0\" || trimmed === \"\" ? \"0\" : trimmed;\n}\n\n/** The single \"on blur / Enter\" transform a numeric field applies: evaluate the\n * text if it's an expression, otherwise normalise it to a bare number string\n * (comma → dot, dropping stray characters, non-leading minuses and anything after\n * a second decimal point).\n *\n * The last clause is the backstop for Keksdose live #201. A field the user typed in\n * cannot reach here malformed any more — {@link sanitizeLive} runs on every change,\n * including a paste — but a value handed in from elsewhere (a recurring rule, an\n * import, a test) still can, and \"1.2.3\" is not an expression (no operator), so it\n * used to fall straight through unchanged and be read as NaN. Here the text is CUT\n * at the second dot (\"1.2\") rather than joined (\"1.23\"): with no keystroke to\n * ignore there is nothing to say which reading was meant, and the shorter one\n * cannot silently invent a bigger number. */\nexport function commitExpression(raw: string): string {\n  const s = raw.trim();\n  if (looksLikeExpression(s)) {\n    const n = evaluateExpression(s);\n    if (n !== null) return formatResult(n);\n    // Unparseable (e.g. a half-typed \"12+\"): fall through to a digits-only clean.\n  }\n  // Global, like sanitizeLive's: these two are the two halves of one rule and must\n  // not appear to state it differently. (The `[^0-9.-]` strip on the same line\n  // already ate whatever commas a non-global replace missed, so this changes no\n  // behaviour — it removes the need for the next reader to run it to find that out.)\n  const cleaned = s.replace(/,/g, \".\").replace(/[^0-9.-]/g, \"\").replace(/(?!^)-/g, \"\");\n  return cleaned.replace(/^(-?\\d*\\.?\\d*).*$/, \"$1\");\n}\n\n/** The live, per-keystroke transform a numeric field applies: comma → dot and\n * drop anything that isn't a digit, decimal point, arithmetic operator (incl.\n * the on-screen `× ÷` glyphs) or paren — so a typed calculation survives\n * keystroke-by-keystroke but stray characters can't be entered. A lone leading\n * `-` is kept — in a plain field it is simply a negative amount; in a field whose\n * caller owns the sign it is read off again by {@link splitLeadingSign}. The text\n * is resolved to a plain number on blur/Enter via {@link commitExpression}. */\nexport function sanitizeLive(raw: string): string {\n  return dropExtraDots(raw.replace(/,/g, \".\").replace(/[^0-9.+\\-*/×÷()]/g, \"\"));\n}\n\n/**\n * At most ONE decimal point per number (Keksdose live #201).\n *\n * Per NUMBER, not per string: \"1.5+2.5\" is a legitimate calculation with two dots\n * in two operands, so the counter resets at every operator and parenthesis.\n *\n * A second dot inside one operand is a **no-op keystroke** — the digits after it\n * keep landing, so \"1.2\" + \".\" + \"3\" is \"1.23\". That is what every calculator does\n * with a repeated decimal point, and it is the only option that does not make the\n * field feel broken (\"my 3 disappeared\"). This runs on paste as well as on typing,\n * so the malformed value never reaches the rest of the app: everything downstream\n * reads the field with `Number()`, NaN became a silent 0, and on the create form\n * that 0 was painted with the income green — a figure that was not a number at all\n * asserting money was coming in.\n */\nfunction dropExtraDots(s: string): string {\n  let out = \"\";\n  let dotInNumber = false;\n  for (const ch of s) {\n    if (ch === \".\") {\n      if (dotInNumber) continue;\n      dotInNumber = true;\n    } else if (ch < \"0\" || ch > \"9\") {\n      // An operator or a paren ends the current operand.\n      dotInNumber = false;\n    }\n    out += ch;\n  }\n  return out;\n}\n\n/** A bare, unsigned amount: digits with at most one decimal separator and nothing\n *  else — \"42\", \"42.\", \".5\", \"0,5\". NOT \"\" (an empty field has no figure to put a\n *  sign in front of), not \"-42\", not \"12+5\". It is the only shape a DISPLAYED sign\n *  prefix makes sense in front of; an expression carries its own arithmetic and has\n *  to survive keystroke-for-keystroke. */\nexport function isBareAmount(s: string): boolean {\n  const t = s.trim();\n  return t !== \"\" && /^\\d*[.,]?\\d*$/.test(t);\n}\n\n/**\n * Split a LEADING sign off a plain signed number (Keksdose live #201 rework):\n * `\"-42\"` → `{ sign: \"-\", rest: \"42\" }`, everything else → `{ sign: \"\", rest: text }`.\n *\n * Only in front of a bare amount, because a minus with arithmetic after it IS\n * arithmetic: \"12-30\" is a subtraction, and \"-12+5\" is -7, not -(12+5). Those come\n * back untouched and are resolved by {@link commitExpression} on blur — at which\n * point the RESULT is a plain signed number and this function does get to speak.\n *\n * A lone \"-\" splits (rest \"\"): the sign is a statement about the direction the\n * moment it is typed, before any digit exists.\n */\nexport function splitLeadingSign(text: string): { sign: \"\" | \"-\" | \"+\"; rest: string } {\n  const trimmed = text.trimStart();\n  const sign = trimmed.charAt(0);\n  if (sign !== \"-\" && sign !== \"+\") return { sign: \"\", rest: text };\n  const rest = trimmed.slice(1);\n  if (rest !== \"\" && !isBareAmount(rest)) return { sign: \"\", rest: text };\n  return { sign, rest };\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cn.d.ts

@@ -0,0 +1,6 @@
+import { clsx } from 'clsx';
+
+/** Merge class lists with Tailwind conflict resolution (later wins). */
+declare const cn: (...inputs: Parameters<typeof clsx>) => string;
+
+export { cn };

package/dist/lib/cn.js

@@ -0,0 +1,7 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+const cn = (...inputs) => twMerge(clsx(inputs));
+export {
+  cn
+};
+//# sourceMappingURL=cn.js.map

package/dist/lib/cn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/cn.ts"],"sourcesContent":["import { clsx } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\n\n/** Merge class lists with Tailwind conflict resolution (later wins). */\nexport const cn = (...inputs: Parameters<typeof clsx>) => twMerge(clsx(inputs));\n"],"mappings":"AAAA,SAAS,YAAY;AACrB,SAAS,eAAe;AAGjB,MAAM,KAAK,IAAI,WAAoC,QAAQ,KAAK,MAAM,CAAC;","names":[]}

package/dist/lib/dates.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ISO date helpers, collected from copies that were scattered across the pages.
+ *
+ * **Every "what day is it" helper here reads the LOCAL calendar** — one family, not
+ * two. It used to be two: these all built a local Date and then read it back through
+ * `toISOString()`, which is UTC, so east of Greenwich they all returned YESTERDAY
+ * between local midnight and the UTC rollover. The old module note called that
+ * deliberate and warned against changing it. It was not defensible, and dev#471 is
+ * what it cost:
+ *
+ * > *"Just entered a tx now from scheduled. But it still shows as upcoming. Is there
+ * > a problem with timezones? It is currently 1 o clock middle european summer time."*
+ *
+ * There was: at 01:00 CEST `todayIso()` answered with the 14th, the row the scheduler
+ * had just booked was dated the 15th, and `isUpcoming` compares the two strings — so a
+ * transaction entered a second ago read as one still to come. The same slip moved
+ * `startOfMonthIso()` onto the last day of the PREVIOUS month for an hour every first
+ * of the month, which is a report range nobody would have questioned.
+ *
+ * A calendar day only means anything to the human reading it, and every caller here —
+ * the register's today, the date-range presets, the budget cursor, a new
+ * transaction's default date — is asking that question. There is no caller for whom
+ * "the UTC day" is the right answer; the server compares plain dates with no zone at
+ * all, so sending it the user's local day is also what it wants.
+ */
+/** Zero-pad a number to two digits ("3" -> "03"). */
+declare function pad(n: number): string;
+/** Today as "YYYY-MM-DD" on the LOCAL calendar (see the module note). */
+declare function todayIso(): string;
+/** A Date as a local-time "YYYY-MM-DD" string. */
+declare function toLocalIso(d: Date): string;
+/** A Date as a local-time "YYYY-MM" month key. */
+declare function monthKey(d: Date): string;
+/** Today shifted by `days`, as "YYYY-MM-DD". */
+declare function shiftIso(days: number): string;
+/** First day (Monday) of the current week, as "YYYY-MM-DD". */
+declare function startOfWeekIso(): string;
+/** First day of the month `offsetMonths` from now, as "YYYY-MM-DD". */
+declare function startOfMonthIso(offsetMonths?: number): string;
+/** Last day of the month `offsetMonths` from now, as "YYYY-MM-DD". */
+declare function endOfMonthIso(offsetMonths?: number): string;
+/** First day of the year `offsetYears` from now, as "YYYY-MM-DD". */
+declare function startOfYearIso(offsetYears?: number): string;
+/** Last day of the year `offsetYears` from now, as "YYYY-MM-DD". */
+declare function endOfYearIso(offsetYears?: number): string;
+/** Parse a "YYYY-MM-DD" string to a local-midnight Date, or null if malformed —
+ *  where "malformed" includes a date that does not exist.
+ *
+ *  The falsy check alone was not enough. `new Date(y, m - 1, d)` ROLLS OVER out-of-range
+ *  components rather than refusing them, so "2026-13-45" came back as 2027-02-14 and
+ *  "2026-02-30" as 2026-03-02: a valid-looking Date for a day that never happened. No
+ *  caller could tell — {@link formatIsoDate} blanks only on `null`, so the invented
+ *  date formatted and displayed exactly like a real one.
+ *
+ *  The round-trip is the check: build the Date, then read the components back off it.
+ *  A value that rolled over cannot answer with the numbers it was given. That is the
+ *  same shape {@link sameYmd} already expresses, applied to a Date and its source. */
+declare function parseIsoDate(s: string): Date | null;
+/** Format a "YYYY-MM-DD" string for display in `locale` (empty string when
+ *  unparseable). Defaults to the locale's short numeric date; pass `options` to
+ *  override (e.g. `{ dateStyle: "medium" }`). */
+declare function formatIsoDate(iso: string, locale: string, options?: Intl.DateTimeFormatOptions): string;
+/** A "YYYY-MM-DD" string shifted by `days` (negative shifts back), or the input
+ *  unchanged when it isn't a parseable date.
+ *
+ *  Local-time throughout — {@link parseIsoDate} builds a local-midnight Date and
+ *  {@link toLocalIso} reads local components back, so this never slides a day the way
+ *  a `toISOString()` round-trip does west of UTC. */
+declare function addDaysIso(iso: string, days: number): string;
+/** Whether two Dates fall on the same local calendar day. */
+declare function sameYmd(a: Date, b: Date): boolean;
+interface DateRangePreset {
+    key: string;
+    from: string;
+    to: string;
+}
+/**
+ * The named ranges offered by the data-table date filter (local-calendar, like
+ * {@link todayIso} — see the module note). `key` maps to the consumer's
+ * `table.preset_*` labels.
+ */
+declare function dateRangePresets(): DateRangePreset[];
+
+export { type DateRangePreset, addDaysIso, dateRangePresets, endOfMonthIso, endOfYearIso, formatIsoDate, monthKey, pad, parseIsoDate, sameYmd, shiftIso, startOfMonthIso, startOfWeekIso, startOfYearIso, toLocalIso, todayIso };

package/dist/lib/dates.js

@@ -0,0 +1,108 @@
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+function todayIso() {
+  return toLocalIso(/* @__PURE__ */ new Date());
+}
+function toLocalIso(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function monthKey(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}`;
+}
+function shiftIso(days) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() + days);
+  return toLocalIso(d);
+}
+function startOfWeekIso() {
+  const d = /* @__PURE__ */ new Date();
+  const day = d.getDay();
+  const diff = (day + 6) % 7;
+  d.setDate(d.getDate() - diff);
+  return toLocalIso(d);
+}
+function startOfMonthIso(offsetMonths = 0) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(1);
+  d.setMonth(d.getMonth() + offsetMonths);
+  return toLocalIso(d);
+}
+function endOfMonthIso(offsetMonths = 0) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(1);
+  d.setMonth(d.getMonth() + offsetMonths + 1);
+  d.setDate(0);
+  return toLocalIso(d);
+}
+function startOfYearIso(offsetYears = 0) {
+  const d = /* @__PURE__ */ new Date();
+  d.setMonth(0);
+  d.setDate(1);
+  d.setFullYear(d.getFullYear() + offsetYears);
+  return toLocalIso(d);
+}
+function endOfYearIso(offsetYears = 0) {
+  const d = /* @__PURE__ */ new Date();
+  d.setMonth(11);
+  d.setDate(31);
+  d.setFullYear(d.getFullYear() + offsetYears);
+  return toLocalIso(d);
+}
+function parseIsoDate(s) {
+  if (!s) return null;
+  const [y, m, d] = s.split("-").map(Number);
+  if (!y || !m || !d) return null;
+  if (!Number.isInteger(y) || !Number.isInteger(m) || !Number.isInteger(d)) return null;
+  const dt = new Date(y, m - 1, d);
+  if (Number.isNaN(dt.getTime())) return null;
+  if (dt.getFullYear() !== y || dt.getMonth() !== m - 1 || dt.getDate() !== d) return null;
+  return dt;
+}
+function formatIsoDate(iso, locale, options) {
+  const d = parseIsoDate(iso);
+  return d ? d.toLocaleDateString(locale, options) : "";
+}
+function addDaysIso(iso, days) {
+  const d = parseIsoDate(iso);
+  if (!d) return iso;
+  d.setDate(d.getDate() + days);
+  return toLocalIso(d);
+}
+function sameYmd(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function dateRangePresets() {
+  const mondayOffset = ((/* @__PURE__ */ new Date()).getDay() + 6) % 7;
+  return [
+    { key: "today", from: todayIso(), to: todayIso() },
+    { key: "yesterday", from: shiftIso(-1), to: shiftIso(-1) },
+    { key: "this_week", from: startOfWeekIso(), to: todayIso() },
+    { key: "last_week", from: shiftIso(-7 - mondayOffset), to: shiftIso(-1 - mondayOffset) },
+    { key: "last_7_days", from: shiftIso(-6), to: todayIso() },
+    { key: "last_30_days", from: shiftIso(-29), to: todayIso() },
+    { key: "this_month", from: startOfMonthIso(0), to: todayIso() },
+    { key: "last_month", from: startOfMonthIso(-1), to: endOfMonthIso(-1) },
+    { key: "last_3_months", from: shiftIso(-90), to: todayIso() },
+    { key: "ytd", from: startOfYearIso(0), to: todayIso() },
+    { key: "last_year", from: startOfYearIso(-1), to: endOfYearIso(-1) }
+  ];
+}
+export {
+  addDaysIso,
+  dateRangePresets,
+  endOfMonthIso,
+  endOfYearIso,
+  formatIsoDate,
+  monthKey,
+  pad,
+  parseIsoDate,
+  sameYmd,
+  shiftIso,
+  startOfMonthIso,
+  startOfWeekIso,
+  startOfYearIso,
+  toLocalIso,
+  todayIso
+};
+//# sourceMappingURL=dates.js.map

package/dist/lib/dates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/dates.ts"],"sourcesContent":["/**\n * ISO date helpers, collected from copies that were scattered across the pages.\n *\n * **Every \"what day is it\" helper here reads the LOCAL calendar** — one family, not\n * two. It used to be two: these all built a local Date and then read it back through\n * `toISOString()`, which is UTC, so east of Greenwich they all returned YESTERDAY\n * between local midnight and the UTC rollover. The old module note called that\n * deliberate and warned against changing it. It was not defensible, and dev#471 is\n * what it cost:\n *\n * > *\"Just entered a tx now from scheduled. But it still shows as upcoming. Is there\n * > a problem with timezones? It is currently 1 o clock middle european summer time.\"*\n *\n * There was: at 01:00 CEST `todayIso()` answered with the 14th, the row the scheduler\n * had just booked was dated the 15th, and `isUpcoming` compares the two strings — so a\n * transaction entered a second ago read as one still to come. The same slip moved\n * `startOfMonthIso()` onto the last day of the PREVIOUS month for an hour every first\n * of the month, which is a report range nobody would have questioned.\n *\n * A calendar day only means anything to the human reading it, and every caller here —\n * the register's today, the date-range presets, the budget cursor, a new\n * transaction's default date — is asking that question. There is no caller for whom\n * \"the UTC day\" is the right answer; the server compares plain dates with no zone at\n * all, so sending it the user's local day is also what it wants.\n */\n\n/** Zero-pad a number to two digits (\"3\" -> \"03\"). */\nexport function pad(n: number): string {\n  return String(n).padStart(2, \"0\");\n}\n\n/** Today as \"YYYY-MM-DD\" on the LOCAL calendar (see the module note). */\nexport function todayIso(): string {\n  return toLocalIso(new Date());\n}\n\n/** A Date as a local-time \"YYYY-MM-DD\" string. */\nexport function toLocalIso(d: Date): string {\n  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;\n}\n\n/** A Date as a local-time \"YYYY-MM\" month key. */\nexport function monthKey(d: Date): string {\n  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}`;\n}\n\n// ---------- Date-range presets + calendar helpers ----------\n// Local-calendar like todayIso (see the module note); used by the data-table date\n// filter and its MiniCalendar. Each one mutates a local Date and must therefore READ\n// it back locally — going out through toISOString() is what shifted every one of\n// these by a day near midnight (dev#471).\n\n/** Today shifted by `days`, as \"YYYY-MM-DD\". */\nexport function shiftIso(days: number): string {\n  const d = new Date();\n  d.setDate(d.getDate() + days);\n  return toLocalIso(d);\n}\n\n/** First day (Monday) of the current week, as \"YYYY-MM-DD\". */\nexport function startOfWeekIso(): string {\n  const d = new Date();\n  const day = d.getDay();\n  const diff = (day + 6) % 7; // monday = 0\n  d.setDate(d.getDate() - diff);\n  return toLocalIso(d);\n}\n\n/** First day of the month `offsetMonths` from now, as \"YYYY-MM-DD\". */\nexport function startOfMonthIso(offsetMonths = 0): string {\n  const d = new Date();\n  d.setDate(1);\n  d.setMonth(d.getMonth() + offsetMonths);\n  return toLocalIso(d);\n}\n\n/** Last day of the month `offsetMonths` from now, as \"YYYY-MM-DD\". */\nexport function endOfMonthIso(offsetMonths = 0): string {\n  const d = new Date();\n  d.setDate(1);\n  d.setMonth(d.getMonth() + offsetMonths + 1);\n  d.setDate(0);\n  return toLocalIso(d);\n}\n\n/** First day of the year `offsetYears` from now, as \"YYYY-MM-DD\". */\nexport function startOfYearIso(offsetYears = 0): string {\n  const d = new Date();\n  d.setMonth(0);\n  d.setDate(1);\n  d.setFullYear(d.getFullYear() + offsetYears);\n  return toLocalIso(d);\n}\n\n/** Last day of the year `offsetYears` from now, as \"YYYY-MM-DD\". */\nexport function endOfYearIso(offsetYears = 0): string {\n  const d = new Date();\n  d.setMonth(11);\n  d.setDate(31);\n  d.setFullYear(d.getFullYear() + offsetYears);\n  return toLocalIso(d);\n}\n\n/** Parse a \"YYYY-MM-DD\" string to a local-midnight Date, or null if malformed —\n *  where \"malformed\" includes a date that does not exist.\n *\n *  The falsy check alone was not enough. `new Date(y, m - 1, d)` ROLLS OVER out-of-range\n *  components rather than refusing them, so \"2026-13-45\" came back as 2027-02-14 and\n *  \"2026-02-30\" as 2026-03-02: a valid-looking Date for a day that never happened. No\n *  caller could tell — {@link formatIsoDate} blanks only on `null`, so the invented\n *  date formatted and displayed exactly like a real one.\n *\n *  The round-trip is the check: build the Date, then read the components back off it.\n *  A value that rolled over cannot answer with the numbers it was given. That is the\n *  same shape {@link sameYmd} already expresses, applied to a Date and its source. */\nexport function parseIsoDate(s: string): Date | null {\n  if (!s) return null;\n  const [y, m, d] = s.split(\"-\").map(Number);\n  if (!y || !m || !d) return null;\n  if (!Number.isInteger(y) || !Number.isInteger(m) || !Number.isInteger(d)) return null;\n  const dt = new Date(y, m - 1, d);\n  if (Number.isNaN(dt.getTime())) return null;\n  if (dt.getFullYear() !== y || dt.getMonth() !== m - 1 || dt.getDate() !== d) return null;\n  return dt;\n}\n\n/** Format a \"YYYY-MM-DD\" string for display in `locale` (empty string when\n *  unparseable). Defaults to the locale's short numeric date; pass `options` to\n *  override (e.g. `{ dateStyle: \"medium\" }`). */\nexport function formatIsoDate(\n  iso: string,\n  locale: string,\n  options?: Intl.DateTimeFormatOptions,\n): string {\n  const d = parseIsoDate(iso);\n  return d ? d.toLocaleDateString(locale, options) : \"\";\n}\n\n/** A \"YYYY-MM-DD\" string shifted by `days` (negative shifts back), or the input\n *  unchanged when it isn't a parseable date.\n *\n *  Local-time throughout — {@link parseIsoDate} builds a local-midnight Date and\n *  {@link toLocalIso} reads local components back, so this never slides a day the way\n *  a `toISOString()` round-trip does west of UTC. */\nexport function addDaysIso(iso: string, days: number): string {\n  const d = parseIsoDate(iso);\n  if (!d) return iso;\n  d.setDate(d.getDate() + days);\n  return toLocalIso(d);\n}\n\n/** Whether two Dates fall on the same local calendar day. */\nexport function sameYmd(a: Date, b: Date): boolean {\n  return (\n    a.getFullYear() === b.getFullYear() &&\n    a.getMonth() === b.getMonth() &&\n    a.getDate() === b.getDate()\n  );\n}\n\nexport interface DateRangePreset {\n  key: string;\n  from: string;\n  to: string;\n}\n\n/**\n * The named ranges offered by the data-table date filter (local-calendar, like\n * {@link todayIso} — see the module note). `key` maps to the consumer's\n * `table.preset_*` labels.\n */\nexport function dateRangePresets(): DateRangePreset[] {\n  const mondayOffset = (new Date().getDay() + 6) % 7; // monday = 0\n  return [\n    { key: \"today\", from: todayIso(), to: todayIso() },\n    { key: \"yesterday\", from: shiftIso(-1), to: shiftIso(-1) },\n    { key: \"this_week\", from: startOfWeekIso(), to: todayIso() },\n    { key: \"last_week\", from: shiftIso(-7 - mondayOffset), to: shiftIso(-1 - mondayOffset) },\n    { key: \"last_7_days\", from: shiftIso(-6), to: todayIso() },\n    { key: \"last_30_days\", from: shiftIso(-29), to: todayIso() },\n    { key: \"this_month\", from: startOfMonthIso(0), to: todayIso() },\n    { key: \"last_month\", from: startOfMonthIso(-1), to: endOfMonthIso(-1) },\n    { key: \"last_3_months\", from: shiftIso(-90), to: todayIso() },\n    { key: \"ytd\", from: startOfYearIso(0), to: todayIso() },\n    { key: \"last_year\", from: startOfYearIso(-1), to: endOfYearIso(-1) },\n  ];\n}\n"],"mappings":"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","names":[]}

package/dist/lib/logger.d.ts

@@ -0,0 +1,17 @@
+import { StoreMutatorIdentifier, StateCreator } from 'zustand';
+
+/**
+ * zustand logging middleware.
+ *
+ * Logs every state transition (a store "action") to the DevTools console as a
+ * single grouped line showing the prev/next state. Enabled in dev (Vite
+ * `import.meta.env.DEV`) by default; override at runtime with
+ * `localStorage.setItem("store_log", "0")` to silence or `"1"` to force-on in a
+ * production build.
+ */
+type Logger = <T, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = []>(f: StateCreator<T, Mps, Mcs>, name?: string) => StateCreator<T, Mps, Mcs>;
+/** Turn store logging on or off for the rest of the session (devtools escape hatch). */
+declare function setStoreLog(enabled: boolean): void;
+declare const logger: Logger;
+
+export { logger, setStoreLog };

package/dist/lib/logger.js

@@ -0,0 +1,30 @@
+import { readStored } from "./safe-storage.js";
+let storeLog = (() => {
+  const override = readStored("store_log");
+  if (override === "0") return false;
+  if (override === "1") return true;
+  return Boolean(import.meta.env?.DEV) && !import.meta.env?.VITEST;
+})();
+function setStoreLog(enabled) {
+  storeLog = enabled;
+}
+const loggerImpl = (f, name) => (set, get, store) => {
+  const loggedSet = ((...args) => {
+    const prev = get();
+    set(...args);
+    if (storeLog) {
+      console.debug(
+        `%c[store${name ? `:${name}` : ""}]`,
+        "color:#0d9488",
+        { prev, next: get() }
+      );
+    }
+  });
+  return f(loggedSet, get, store);
+};
+const logger = loggerImpl;
+export {
+  logger,
+  setStoreLog
+};
+//# sourceMappingURL=logger.js.map

package/dist/lib/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/logger.ts"],"sourcesContent":["import type { StateCreator, StoreMutatorIdentifier } from \"zustand\";\n\nimport { readStored } from \"./safe-storage\";\n\n/**\n * zustand logging middleware.\n *\n * Logs every state transition (a store \"action\") to the DevTools console as a\n * single grouped line showing the prev/next state. Enabled in dev (Vite\n * `import.meta.env.DEV`) by default; override at runtime with\n * `localStorage.setItem(\"store_log\", \"0\")` to silence or `\"1\"` to force-on in a\n * production build.\n */\ntype Logger = <\n  T,\n  Mps extends [StoreMutatorIdentifier, unknown][] = [],\n  Mcs extends [StoreMutatorIdentifier, unknown][] = [],\n>(\n  f: StateCreator<T, Mps, Mcs>,\n  name?: string,\n) => StateCreator<T, Mps, Mcs>;\n\ntype LoggerImpl = <T>(f: StateCreator<T, [], []>, name?: string) => StateCreator<T, [], []>;\n\n/**\n * Read ONCE, at module scope, not on every `set`.\n *\n * This used to run inside the wrapped `set`, which means a synchronous\n * `localStorage.getItem` on every state transition of every logged store — in\n * production builds too, because the override has to stay readable there by design.\n * The stores this middleware wraps include ones that transition per pointer event.\n *\n * The override cannot change without someone opening devtools and reloading, so\n * once per session is the same behaviour at a fraction of the cost. {@link setStoreLog}\n * keeps the ability to flip it live from a console, which is the only thing the\n * per-call read was actually buying.\n */\nlet storeLog: boolean = (() => {\n  const override = readStored(\"store_log\");\n  if (override === \"0\") return false;\n  if (override === \"1\") return true;\n  // NOT under vitest. `DEV` distinguishes a dev build from a production one; a test\n  // run is neither, and vitest sets `DEV=true` — so every transition of every logged\n  // store printed a prev/next object into the suite output. Measured on the consumer's\n  // suite: 822 blocks, several thousand lines, in a log whose whole job is to make one\n  // real `console.error` findable. `store_log=1` still forces it on.\n  // Optional-chained because `import.meta.env` is a Vite injection: it is\n  // undefined under plain Node ESM, and this package is published publicly,\n  // so a non-Vite consumer must be able to import it without throwing.\n  return Boolean(import.meta.env?.DEV) && !import.meta.env?.VITEST;\n})();\n\n/** Turn store logging on or off for the rest of the session (devtools escape hatch). */\nexport function setStoreLog(enabled: boolean): void {\n  storeLog = enabled;\n}\n\nconst loggerImpl: LoggerImpl = (f, name) => (set, get, store) => {\n  const loggedSet = ((...args: unknown[]) => {\n    const prev = get();\n    (set as (...a: unknown[]) => void)(...args);\n    if (storeLog) {\n      console.debug(\n        `%c[store${name ? `:${name}` : \"\"}]`,\n        \"color:#0d9488\",\n        { prev, next: get() },\n      );\n    }\n  }) as typeof set;\n  return f(loggedSet, get, store);\n};\n\nexport const logger = loggerImpl as unknown as Logger;\n"],"mappings":"AAEA,SAAS,kBAAkB;AAmC3B,IAAI,YAAqB,MAAM;AAC7B,QAAM,WAAW,WAAW,WAAW;AACvC,MAAI,aAAa,IAAK,QAAO;AAC7B,MAAI,aAAa,IAAK,QAAO;AAS7B,SAAO,QAAQ,YAAY,KAAK,GAAG,KAAK,CAAC,YAAY,KAAK;AAC5D,GAAG;AAGI,SAAS,YAAY,SAAwB;AAClD,aAAW;AACb;AAEA,MAAM,aAAyB,CAAC,GAAG,SAAS,CAAC,KAAK,KAAK,UAAU;AAC/D,QAAM,aAAa,IAAI,SAAoB;AACzC,UAAM,OAAO,IAAI;AACjB,IAAC,IAAkC,GAAG,IAAI;AAC1C,QAAI,UAAU;AACZ,cAAQ;AAAA,QACN,WAAW,OAAO,IAAI,IAAI,KAAK,EAAE;AAAA,QACjC;AAAA,QACA,EAAE,MAAM,MAAM,IAAI,EAAE;AAAA,MACtB;AAAA,IACF;AAAA,EACF;AACA,SAAO,EAAE,WAAW,KAAK,KAAK;AAChC;AAEO,MAAM,SAAS;","names":[]}

package/dist/lib/safe-storage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `localStorage` that cannot take the page down with it.
+ *
+ * Accessing `window.localStorage` **throws** — rather than returning null — when a
+ * browser has site data blocked: Safari private browsing, Chrome with third-party
+ * site data disabled, a partitioned webview. Three places in this package already
+ * knew that and wrapped their calls in try/catch (`logger.ts`, and the DataTable's
+ * `loadPersisted`/`savePersisted`). One did not: `AppShell` read the sidebar's
+ * collapse flag straight out of a `useState` initialiser, so the throw happened
+ * during render of the application's top-level shell. That is not a lost preference
+ * — nothing mounts, in every consumer of this package at once.
+ *
+ * So the guard lives here, once, and the next storage-backed preference cannot
+ * forget it. A read that cannot happen is indistinguishable from a key that was
+ * never set, which is the right answer for every caller: the default.
+ */
+/** The stored string for `key`, or null when absent, unreadable, or blocked. */
+declare function readStored(key: string): string | null;
+/** Store `value` under `key`, silently doing nothing when storage is unavailable
+ *  or full. A preference that cannot be persisted is not worth an exception. */
+declare function writeStored(key: string, value: string): void;
+
+export { readStored, writeStored };

package/dist/lib/safe-storage.js

@@ -0,0 +1,20 @@
+function readStored(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeStored(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+  }
+}
+export {
+  readStored,
+  writeStored
+};
+//# sourceMappingURL=safe-storage.js.map

package/dist/lib/safe-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/safe-storage.ts"],"sourcesContent":["/**\n * `localStorage` that cannot take the page down with it.\n *\n * Accessing `window.localStorage` **throws** — rather than returning null — when a\n * browser has site data blocked: Safari private browsing, Chrome with third-party\n * site data disabled, a partitioned webview. Three places in this package already\n * knew that and wrapped their calls in try/catch (`logger.ts`, and the DataTable's\n * `loadPersisted`/`savePersisted`). One did not: `AppShell` read the sidebar's\n * collapse flag straight out of a `useState` initialiser, so the throw happened\n * during render of the application's top-level shell. That is not a lost preference\n * — nothing mounts, in every consumer of this package at once.\n *\n * So the guard lives here, once, and the next storage-backed preference cannot\n * forget it. A read that cannot happen is indistinguishable from a key that was\n * never set, which is the right answer for every caller: the default.\n */\n\n/** The stored string for `key`, or null when absent, unreadable, or blocked. */\nexport function readStored(key: string): string | null {\n  if (typeof window === \"undefined\") return null;\n  try {\n    return window.localStorage.getItem(key);\n  } catch {\n    return null;\n  }\n}\n\n/** Store `value` under `key`, silently doing nothing when storage is unavailable\n *  or full. A preference that cannot be persisted is not worth an exception. */\nexport function writeStored(key: string, value: string): void {\n  if (typeof window === \"undefined\") return;\n  try {\n    window.localStorage.setItem(key, value);\n  } catch {\n    // ignore (private mode, quota, partitioned storage)\n  }\n}\n"],"mappings":"AAkBO,SAAS,WAAW,KAA4B;AACrD,MAAI,OAAO,WAAW,YAAa,QAAO;AAC1C,MAAI;AACF,WAAO,OAAO,aAAa,QAAQ,GAAG;AAAA,EACxC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAIO,SAAS,YAAY,KAAa,OAAqB;AAC5D,MAAI,OAAO,WAAW,YAAa;AACnC,MAAI;AACF,WAAO,aAAa,QAAQ,KAAK,KAAK;AAAA,EACxC,QAAQ;AAAA,EAER;AACF;","names":[]}

package/dist/search/command-palette.d.ts

@@ -0,0 +1,71 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+interface CommandItem {
+    id: string;
+    /** Primary text. */
+    label: string;
+    /** Secondary text on the right (e.g. an amount, a date, a group hint). */
+    hint?: string;
+    /** Heading this item is grouped under. */
+    group: string;
+    /** Leading icon / element. */
+    icon?: ReactNode;
+    /** Invoked when the item is chosen (navigate, run an action, …). */
+    onSelect: () => void;
+    /** Where this item leads, when it is a navigation rather than an action. Renders
+     *  the row as a real anchor so it can be middle-/⌘-clicked into a new tab
+     *  (Keksdose feedback #451); `onSelect` still runs for a plain click and for ↵, so
+     *  in-app navigation stays client-side. `href` only adds what the browser can do
+     *  with a link and JavaScript cannot fake — the rejected alternative, an
+     *  `onAuxClick` calling `window.open`, gets the middle click and nothing else. */
+    href?: string;
+}
+interface CommandPaletteLabels {
+    placeholder: string;
+    empty: string;
+    loading: string;
+    /** Hint shown in the footer, e.g. "↑↓ to navigate · ↵ to select · esc to close". */
+    hint?: string;
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onClose: () => void;
+    /**
+     * Returns results for a query (called debounced as the user types; an empty
+     * query is allowed — return defaults like pages/recent). Sync or async; stale
+     * async responses are ignored.
+     *
+     * Its IDENTITY is not a re-run signal — it is read through a ref, so the palette
+     * never re-searches merely because the caller rebuilt the callback. That is
+     * deliberate: a provider closing over a list rendered from a query allocates a new
+     * function on most renders, and re-running the search on each would make typing
+     * stutter. Use {@link CommandPaletteProps.revision} when the DATA behind the
+     * provider changes.
+     */
+    search: (query: string) => CommandItem[] | Promise<CommandItem[]>;
+    /**
+     * Anything whose change means the current results are out of date — typically the
+     * arrays the provider searches over. Compared by identity (as an effect dependency
+     * would be), so pass stable references: a `data = []` default allocates a fresh
+     * array on every render while a query is pending and would re-search forever.
+     *
+     * Without it, a provider whose data arrives AFTER the palette opened never gets
+     * asked again: the user's last keystroke settles the debounce, the queries resolve a
+     * moment later, and the groups they would have contributed are simply absent until
+     * another keystroke. That is the ordinary first open on a cold cache.
+     */
+    revision?: unknown;
+    labels?: Partial<CommandPaletteLabels>;
+}
+/** Registers a global ⌘K / Ctrl-K shortcut that calls `onOpen`. */
+declare function useCommandKey(onOpen: () => void): void;
+/**
+ * A ⌘K-style command palette: a top-centred modal with a search field and a
+ * grouped, keyboard-navigable result list. Domain-free — the app supplies
+ * results via the `search` provider (pages, actions, records, …); each result
+ * carries its own `onSelect`.
+ */
+declare function CommandPalette({ open, onClose, search, revision, labels, }: CommandPaletteProps): react.ReactPortal | null;
+
+export { type CommandItem, CommandPalette, type CommandPaletteLabels, useCommandKey };