@eifi1/ui-kit 0.24.1 → 0.25.1

package/dist/hooks/use-search-param-state.d.ts

@@ -21,6 +21,9 @@ interface SearchParamStateOptions<T> {
      *    which are not steps anyone wants Back to walk through.
      *  - `"replace-on-clear"`: push when a value is set, replace when it is cleared (the
      *    "open a form, close it" pattern).
+     *
+     * Several writes in one tick (one handler) add at most ONE entry — see
+     * {@link useSearchParamState}.
      */
     history?: "push" | "replace" | "replace-on-clear";
 }
@@ -36,11 +39,63 @@ interface SearchParamStateOptions<T> {
  * * an absent or unparseable param reads as the default, and
  * * setting the default removes the param — the default view is the clean URL.
  *
- * Every other param in the query string is left as it is. Two updates in one tick do
- * not compose — react-router resolves each against the params of the last render.
+ * Every other param in the query string is left as it is.
+ *
+ * **Setters compose** (0.25, keksdose live #378): setters called in a row — of one hook,
+ * or of several hooks under the same router — each build on the write before them, so
+ * `setStatus("open"); setNs("legal")` in one handler leaves both in the URL. react-
+ * router's own `setSearchParams(updater)` does not: it hands every updater the params of
+ * the render, so the last call used to write the others' old values back. The tick's
+ * writes add at most one history entry; see `history`. When the params belong
+ * together, {@link useSearchParamsState} writes them with one setter. A functional
+ * update receives the value as the writes before it left it.
+ *
  * Requires a react-router Router.
  */
 declare function useSearchParamState<T = string>(key: string, defaultValue: T, options?: SearchParamStateOptions<T>): [T, (next: Updater<T>) => void];
+/** One field of {@link useSearchParamsState}: its default, and the single hook's options. */
+interface SearchParamField<T> extends SearchParamStateOptions<T> {
+    /** The value when the param is absent or does not parse; writing it removes the param. */
+    default: T;
+    /** The param's name in the URL. Default: the field's name (`namespace: { param: "ns" }`). */
+    param?: string;
+}
+/** The fields of {@link useSearchParamsState}, one per key of the value object. */
+type SearchParamFields<V> = {
+    [K in keyof V]: SearchParamField<V[K]>;
+};
+/** A partial value (fields left out — or `undefined` — stay as they are), or a function
+ *  of the current value returning one. */
+type SearchParamsUpdate<V> = Partial<V> | ((prev: V) => Partial<V>);
+/**
+ * Several URL search params as ONE state object, with one setter that writes them in
+ * one navigation:
+ *
+ *     const [filter, setFilter] = useSearchParamsState({
+ *       status: { default: "all" as ReviewStatus | "all", parse: toStatus },
+ *       namespace: { param: "ns", default: "all" },
+ *       query: { param: "q", default: "", history: "replace" },
+ *     });
+ *     <TranslationReviewPanel filter={filter} onFilterChange={setFilter} />
+ *
+ * keksdose live #378: a filter bar reports all its filters on every change, and four
+ * single-param setters in a row clobbered each other (see {@link useSearchParamState},
+ * whose setters now compose too). This is the shape that never could: one setter, one
+ * write, every field's rules in one place.
+ *
+ * Each field takes what the single hook takes — `parse`, `serialize`, `history` /
+ * `replace` — and its `default` (the clean URL, as there) and optional `param` name.
+ * The setter takes a partial object or a function of the current one; fields it leaves
+ * out, or sets to `undefined`, stay as they are, and keys that are not fields are
+ * ignored, so a component's whole filter object can be handed over as it is. Its
+ * history is the single hook's rule over the fields that change: one entry, pushed if
+ * any of them asks to push, else the current entry rewritten. Setting what the URL
+ * already says navigates nowhere.
+ *
+ * The value object keeps its identity while its params do not change, so it can sit in
+ * a dependency array. Requires a react-router Router.
+ */
+declare function useSearchParamsState<V extends object>(fields: SearchParamFields<V>): [V, (next: SearchParamsUpdate<V>) => void];
 /**
  * The active tab in `?tab=` (or `key`), with the default tab as the clean URL, for the
  * kit's `Tabs`:
@@ -80,4 +135,4 @@ type DialogParam = string | {
  */
 declare function useDialogParam(param: DialogParam): [boolean, (open: boolean) => void];
 
-export { type DialogParam, type SearchParamStateOptions, useDialogParam, useSearchParamState, useTabParam };
+export { type DialogParam, type SearchParamField, type SearchParamFields, type SearchParamStateOptions, type SearchParamsUpdate, useDialogParam, useSearchParamState, useSearchParamsState, useTabParam };

package/dist/hooks/use-search-param-state.js

@@ -1,47 +1,118 @@
 "use client";
+import { createContext, useContext, useMemo } from "react";
+import * as ReactRouter from "react-router";
 import { useLocation, useNavigate, useSearchParams } from "react-router";
 const defaultSerialize = (value) => value === null || value === void 0 ? null : String(value);
 function carriedState(state) {
   return state && typeof state === "object" ? state : void 0;
 }
-function useSearchParamState(key, defaultValue, options = {}) {
-  const { parse, serialize = defaultSerialize } = options;
-  const history = options.history ?? (options.replace ? "replace" : "push");
-  const [params, setParams] = useSearchParams();
-  const location = useLocation();
-  const read = (raw) => {
-    if (raw === null) return defaultValue;
-    if (!parse) return raw;
-    try {
-      const parsed = parse(raw);
-      return parsed === void 0 ? defaultValue : parsed;
-    } catch {
-      return defaultValue;
-    }
-  };
-  const value = read(params.get(key));
-  const defaultSerialized = serialize(defaultValue);
-  const toParam = (v) => {
-    const s = serialize(v);
-    return s === defaultSerialized ? null : s;
-  };
-  const setValue = (next) => {
-    const preview = typeof next === "function" ? next(value) : next;
-    const replace = history === "replace" || history === "replace-on-clear" && toParam(preview) === null;
-    setParams(
-      (prev) => {
-        const p = new URLSearchParams(prev);
-        const resolved = typeof next === "function" ? next(read(p.get(key))) : next;
-        const serialized = toParam(resolved);
-        if (serialized === null) p.delete(key);
-        else p.set(key, serialized);
-        return p;
-      },
-      replace ? { replace, state: carriedState(location.state) } : void 0
-    );
+function paramRule(key, defaultValue, options) {
+  return {
+    key,
+    defaultValue,
+    parse: options.parse,
+    serialize: options.serialize ?? defaultSerialize,
+    history: options.history ?? (options.replace ? "replace" : "push")
   };
+}
+function readParam(params, rule) {
+  const raw = params.get(rule.key);
+  if (raw === null) return rule.defaultValue;
+  if (!rule.parse) return raw;
+  try {
+    const parsed = rule.parse(raw);
+    return parsed === void 0 ? rule.defaultValue : parsed;
+  } catch {
+    return rule.defaultValue;
+  }
+}
+function putParam(params, rule, value) {
+  const serialized = rule.serialize(value);
+  const next = serialized === rule.serialize(rule.defaultValue) ? null : serialized;
+  const current = params.getAll(rule.key);
+  if (next === null ? current.length === 0 : current.length === 1 && current[0] === next) return null;
+  if (next === null) params.delete(rule.key);
+  else params.set(rule.key, next);
+  return rule.history === "push" || rule.history === "replace-on-clear" && next !== null;
+}
+const queuedByLocation = /* @__PURE__ */ new WeakMap();
+const NO_DATA_ROUTER = createContext(null);
+const DataRouterContext = readDataRouterContext();
+function readDataRouterContext() {
+  try {
+    return ReactRouter.UNSAFE_DataRouterContext ?? NO_DATA_ROUTER;
+  } catch {
+    return NO_DATA_ROUTER;
+  }
+}
+function writeQuery(location, navigate, dataRouter, change) {
+  let queued = queuedByLocation.get(location);
+  if (!queued) {
+    queued = {
+      params: new URLSearchParams(location.search),
+      state: location.state,
+      pushedThisTick: false,
+      lastPushed: false
+    };
+    queuedByLocation.set(location, queued);
+  }
+  const before = queued.params.toString();
+  const wantsPush = change(queued.params);
+  const search = queued.params.toString();
+  if (search === before) return;
+  const loading = (dataRouter?.router?.state?.navigation?.state ?? "idle") !== "idle";
+  const push = queued.lastPushed && loading || wantsPush && !queued.pushedThisTick;
+  if (push) {
+    queued.state = null;
+    if (!queued.pushedThisTick) {
+      queued.pushedThisTick = true;
+      const record = queued;
+      queueMicrotask(() => {
+        record.pushedThisTick = false;
+      });
+    }
+  }
+  queued.lastPushed = push;
+  void navigate(`?${search}`, push ? void 0 : { replace: true, state: carriedState(queued.state) });
+}
+function useQueryWriter() {
+  const location = useLocation();
+  const navigate = useNavigate();
+  const dataRouter = useContext(DataRouterContext);
+  const params = useMemo(() => new URLSearchParams(location.search), [location.search]);
+  return [params, (change) => writeQuery(location, navigate, dataRouter, change)];
+}
+function useSearchParamState(key, defaultValue, options = {}) {
+  const [params, write] = useQueryWriter();
+  const rule = paramRule(key, defaultValue, options);
+  const value = readParam(params, rule);
+  const setValue = (next) => write((query) => {
+    const resolved = typeof next === "function" ? next(readParam(query, rule)) : next;
+    return putParam(query, rule, resolved) === true;
+  });
   return [value, setValue];
 }
+function useSearchParamsState(fields) {
+  const [params, write] = useQueryWriter();
+  const rules = Object.keys(fields).map((name) => {
+    const field = fields[name];
+    return [name, paramRule(field.param ?? name, field.default, field)];
+  });
+  const readAll = (query) => Object.fromEntries(rules.map(([name, rule]) => [name, readParam(query, rule)]));
+  const ownParams = JSON.stringify(rules.map(([name, rule]) => [name, params.getAll(rule.key)]));
+  const values = useMemo(() => readAll(params), [ownParams]);
+  const setValues = (next) => write((query) => {
+    const patch = typeof next === "function" ? next(readAll(query)) : next;
+    let push = false;
+    for (const [name, rule] of rules) {
+      const value = patch[name];
+      if (value === void 0) continue;
+      if (putParam(query, rule, value) === true) push = true;
+    }
+    return push;
+  });
+  return [values, setValues];
+}
 function useTabParam(defaultTab, options = {}) {
   const { key = "tab", tabs } = options;
   return useSearchParamState(key, defaultTab, {
@@ -89,6 +160,7 @@ function useDialogParam(param) {
 export {
   useDialogParam,
   useSearchParamState,
+  useSearchParamsState,
   useTabParam
 };
 //# sourceMappingURL=use-search-param-state.js.map

package/dist/hooks/use-search-param-state.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/hooks/use-search-param-state.ts"],"sourcesContent":["import { useLocation, useNavigate, useSearchParams } from \"react-router\";\n\ntype Updater<T> = T | ((prev: T) => T);\n\nexport interface SearchParamStateOptions<T> {\n  /**\n   * The value of a param that IS present. Return `undefined` (or throw) for a value\n   * that does not parse — a hand-edited or stale link — and the default is used.\n   * Default: the raw string.\n   */\n  parse?: (raw: string) => T | undefined;\n  /**\n   * The param for a value, or `null` to remove it. Default: `String(value)`, and\n   * `null` for `null` / `undefined`. A value that serialises the same as the default\n   * removes the param too, so the default is always the clean URL.\n   */\n  serialize?: (value: T) => string | null;\n  /** Shorthand for `history: \"replace\"`. */\n  replace?: boolean;\n  /**\n   * What a change does to the browser history:\n   *  - `\"push\"` (default): a new entry, so Back undoes the change.\n   *  - `\"replace\"`: the current entry is rewritten — a tab, a sort, a view toggle,\n   *    which are not steps anyone wants Back to walk through.\n   *  - `\"replace-on-clear\"`: push when a value is set, replace when it is cleared (the\n   *    \"open a form, close it\" pattern).\n   */\n  history?: \"push\" | \"replace\" | \"replace-on-clear\";\n}\n\nconst defaultSerialize = (value: unknown): string | null =>\n  value === null || value === undefined ? null : String(value);\n\n/** The route state of the current entry, carried over a `replace` so a query rewrite\n *  does not drop what a navigation put there (a dialog's opener mark, below). */\nfunction carriedState(state: unknown): Record<string, unknown> | undefined {\n  return state && typeof state === \"object\" ? (state as Record<string, unknown>) : undefined;\n}\n\n/**\n * One URL search param as React state: `const [view, setView] = useSearchParamState(\"view\", \"list\")`.\n *\n * Replaces the hand-rolled `setParams((prev) => { const p = new URLSearchParams(prev);\n * …set/delete…; return p })` blocks that keksdose had in a dozen pages and kastlan ported\n * as its own copy of this hook (shared/hooks/use-search-param-state.ts, both apps). The\n * kit's version takes the DEFAULT as an argument rather than inside `parse`, so the\n * two rules that follow from it cannot be forgotten at a call site:\n *\n * * an absent or unparseable param reads as the default, and\n * * setting the default removes the param — the default view is the clean URL.\n *\n * Every other param in the query string is left as it is. Two updates in one tick do\n * not compose — react-router resolves each against the params of the last render.\n * Requires a react-router Router.\n */\nexport function useSearchParamState<T = string>(\n  key: string,\n  defaultValue: T,\n  options: SearchParamStateOptions<T> = {},\n): [T, (next: Updater<T>) => void] {\n  const { parse, serialize = defaultSerialize as (value: T) => string | null } = options;\n  const history = options.history ?? (options.replace ? \"replace\" : \"push\");\n  const [params, setParams] = useSearchParams();\n  const location = useLocation();\n\n  const read = (raw: string | null): T => {\n    if (raw === null) return defaultValue;\n    if (!parse) return raw as unknown as T;\n    try {\n      const parsed = parse(raw);\n      return parsed === undefined ? defaultValue : parsed;\n    } catch {\n      return defaultValue;\n    }\n  };\n  const value = read(params.get(key));\n  const defaultSerialized = serialize(defaultValue);\n  const toParam = (v: T): string | null => {\n    const s = serialize(v);\n    return s === defaultSerialized ? null : s;\n  };\n\n  const setValue = (next: Updater<T>) => {\n    // Resolved against the rendered value only to choose the history mode; the write\n    // resolves again inside react-router's updater, against the params it hands over.\n    const preview = typeof next === \"function\" ? (next as (prev: T) => T)(value) : next;\n    const replace = history === \"replace\" || (history === \"replace-on-clear\" && toParam(preview) === null);\n    setParams(\n      (prev) => {\n        const p = new URLSearchParams(prev);\n        const resolved = typeof next === \"function\" ? (next as (prev: T) => T)(read(p.get(key))) : next;\n        const serialized = toParam(resolved);\n        if (serialized === null) p.delete(key);\n        else p.set(key, serialized);\n        return p;\n      },\n      replace ? { replace, state: carriedState(location.state) } : undefined,\n    );\n  };\n\n  return [value, setValue];\n}\n\n/**\n * The active tab in `?tab=` (or `key`), with the default tab as the clean URL, for the\n * kit's `Tabs`:\n *\n *     const [tab, setTab] = useTabParam(\"overview\", { tabs: [\"overview\", \"history\"] });\n *     <Tabs tabs={…} active={tab} onChange={setTab} />\n *\n * Switching tabs REPLACES the history entry — a tab is a view of this page, not a\n * place Back should step through. `tabs`, when given, turns a param naming no tab (a\n * renamed tab, an old link) into the default rather than into a blank panel.\n * kastlan's use-tab-param.ts, with the validation it did not have.\n */\nexport function useTabParam<T extends string>(\n  defaultTab: T,\n  options: { key?: string; tabs?: readonly T[] } = {},\n): [T, (tab: T) => void] {\n  const { key = \"tab\", tabs } = options;\n  return useSearchParamState<T>(key, defaultTab, {\n    parse: (raw) => (!tabs || (tabs as readonly string[]).includes(raw) ? (raw as T) : undefined),\n    history: \"replace\",\n  });\n}\n\n/** Where a dialog's open state lives: a param's presence (`\"edit\"` → `?edit=1`), or one\n *  value of a shared param (`{ key: \"dialog\", value: \"create-lease\" }`). */\nexport type DialogParam = string | { key: string; value: string };\n\n/** The route-state mark an opener leaves on the entry it pushes, so the close knows it\n *  may go BACK over it rather than add a second entry. */\nconst OPENED_BY_KIT = \"__uiKitDialogParam\";\n\n/**\n * A dialog's open state in the URL, for `Modal`'s `urlParam` and anything else that\n * opens one: `const [open, setOpen] = useDialogParam({ key: \"dialog\", value: \"create\" })`.\n *\n * * **Opening pushes** an entry, so the platform Back gesture closes the dialog — by\n *   leaving the entry — and Forward opens it again, like any other step.\n * * **Closing goes back** over that entry when this hook pushed it, so a closed dialog\n *   leaves no dead entry behind. A dialog that arrived OPEN (a deep link, a reload, a\n *   plain `<Link>` to it) has nothing of ours to go back over, and its close removes the\n *   param in place instead — Back from there leaves the page, as it should.\n *\n * That is why it is not `useSearchParamState`: going back is the only close that\n * leaves the history as it was before the dialog, and only the opener knows whether it\n * may.\n */\nexport function useDialogParam(param: DialogParam): [boolean, (open: boolean) => void] {\n  const { key, value } = typeof param === \"string\" ? { key: param, value: \"1\" } : param;\n  const [params, setParams] = useSearchParams();\n  const location = useLocation();\n  const navigate = useNavigate();\n  const open = typeof param === \"string\" ? params.has(key) : params.get(key) === value;\n  const mark = `${key}=${value}`;\n\n  const setOpen = (next: boolean) => {\n    if (next === open) return;\n    const state = carriedState(location.state);\n    if (next) {\n      setParams(\n        (prev) => {\n          const p = new URLSearchParams(prev);\n          p.set(key, value);\n          return p;\n        },\n        { state: { ...state, [OPENED_BY_KIT]: mark } },\n      );\n      return;\n    }\n    if (state?.[OPENED_BY_KIT] === mark) {\n      void navigate(-1);\n      return;\n    }\n    setParams(\n      (prev) => {\n        const p = new URLSearchParams(prev);\n        p.delete(key);\n        return p;\n      },\n      { replace: true, state },\n    );\n  };\n\n  return [open, setOpen];\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/hooks/use-search-param-state.ts"],"sourcesContent":["import { createContext, useContext, useMemo, type Context } from \"react\";\nimport * as ReactRouter from \"react-router\";\nimport { useLocation, useNavigate, useSearchParams, type Location, type NavigateFunction } from \"react-router\";\n\ntype Updater<T> = T | ((prev: T) => T);\n\nexport interface SearchParamStateOptions<T> {\n  /**\n   * The value of a param that IS present. Return `undefined` (or throw) for a value\n   * that does not parse — a hand-edited or stale link — and the default is used.\n   * Default: the raw string.\n   */\n  parse?: (raw: string) => T | undefined;\n  /**\n   * The param for a value, or `null` to remove it. Default: `String(value)`, and\n   * `null` for `null` / `undefined`. A value that serialises the same as the default\n   * removes the param too, so the default is always the clean URL.\n   */\n  serialize?: (value: T) => string | null;\n  /** Shorthand for `history: \"replace\"`. */\n  replace?: boolean;\n  /**\n   * What a change does to the browser history:\n   *  - `\"push\"` (default): a new entry, so Back undoes the change.\n   *  - `\"replace\"`: the current entry is rewritten — a tab, a sort, a view toggle,\n   *    which are not steps anyone wants Back to walk through.\n   *  - `\"replace-on-clear\"`: push when a value is set, replace when it is cleared (the\n   *    \"open a form, close it\" pattern).\n   *\n   * Several writes in one tick (one handler) add at most ONE entry — see\n   * {@link useSearchParamState}.\n   */\n  history?: \"push\" | \"replace\" | \"replace-on-clear\";\n}\n\nconst defaultSerialize = (value: unknown): string | null =>\n  value === null || value === undefined ? null : String(value);\n\n/** The route state of the current entry, carried over a `replace` so a query rewrite\n *  does not drop what a navigation put there (a dialog's opener mark, below). */\nfunction carriedState(state: unknown): Record<string, unknown> | undefined {\n  return state && typeof state === \"object\" ? (state as Record<string, unknown>) : undefined;\n}\n\n/* ── One param: read and write ───────────────────────────────────────────── */\n\n/** One param's rules — the single hook's arguments, or one field of the multi-key hook. */\ninterface ParamRule<T> {\n  key: string;\n  defaultValue: T;\n  parse?: (raw: string) => T | undefined;\n  serialize: (value: T) => string | null;\n  history: \"push\" | \"replace\" | \"replace-on-clear\";\n}\n\nfunction paramRule<T>(key: string, defaultValue: T, options: SearchParamStateOptions<T>): ParamRule<T> {\n  return {\n    key,\n    defaultValue,\n    parse: options.parse,\n    serialize: options.serialize ?? (defaultSerialize as (value: T) => string | null),\n    history: options.history ?? (options.replace ? \"replace\" : \"push\"),\n  };\n}\n\n/** An absent or unparseable param reads as the default. */\nfunction readParam<T>(params: URLSearchParams, rule: ParamRule<T>): T {\n  const raw = params.get(rule.key);\n  if (raw === null) return rule.defaultValue;\n  if (!rule.parse) return raw as unknown as T;\n  try {\n    const parsed = rule.parse(raw);\n    return parsed === undefined ? rule.defaultValue : parsed;\n  } catch {\n    return rule.defaultValue;\n  }\n}\n\n/**\n * Writes `value` into `params` — the default removes the param. Returns `null` when\n * the param already says that (a write that changes nothing has no say in the history),\n * otherwise whether this change asks for an entry of its own.\n */\nfunction putParam<T>(params: URLSearchParams, rule: ParamRule<T>, value: T): boolean | null {\n  const serialized = rule.serialize(value);\n  const next = serialized === rule.serialize(rule.defaultValue) ? null : serialized;\n  const current = params.getAll(rule.key);\n  if (next === null ? current.length === 0 : current.length === 1 && current[0] === next) return null;\n  if (next === null) params.delete(rule.key);\n  else params.set(rule.key, next);\n  return rule.history === \"push\" || (rule.history === \"replace-on-clear\" && next !== null);\n}\n\n/* ── Writes that compose ─────────────────────────────────────────────────── */\n\n/**\n * The query as the writes made against ONE rendered location leave it — shared by every\n * hook on that router, so a write builds on the one before it instead of on the render.\n *\n * Why this exists (keksdose live #378): react-router's `setSearchParams(updater)` hands\n * its updater `new URLSearchParams(searchParams)` — the params of the RENDER the setter\n * came from, in react-router 7 and 8 alike — not the previous call's result. keksdose\n * wired TranslationReviewPanel's `onFilterChange` to four of these setters (status,\n * source, ns, q); each started from the rendered URL, so the last wrote the old values\n * of the other three back and no filter select had any effect.\n *\n * Keyed by react-router's location object, which is one object per committed location\n * per router: every hook under a router reads the same one, a second router (another\n * test) has its own, and when react-router renders the next location this record is\n * unreachable — nothing queued outlives the navigation it belongs to. Until then a\n * later write builds on it even a tick on (a transition or a data router's loaders still\n * pending), which is what keeps two quick clicks from clobbering each other either. The\n * one cost: a navigation a data router's blocker stops leaves its writes here, and the\n * page's next write carries them again — the blocker asks again.\n */\ninterface QueuedQuery {\n  /** The query with every write against this location so far. */\n  params: URLSearchParams;\n  /** The route state of the entry those writes now sit on, carried over a replace. */\n  state: unknown;\n  /** A write in the current tick pushed; the tick's later writes rewrite that entry. */\n  pushedThisTick: boolean;\n  /** The last navigation sent was a push. */\n  lastPushed: boolean;\n}\n\nconst queuedByLocation = new WeakMap<Location, QueuedQuery>();\n\n/**\n * The data router's own state, read for ONE question: is a navigation still loading?\n * A data router whose loaders run commits a navigation only when they finish, and a\n * second `navigate` before then cancels the first — so a push followed by a replace\n * in the same tick would land as a replace alone. `UNSAFE_DataRouterContext` is in\n * react-router 6.4 through 8; read off the namespace with a stand-in, a release\n * without it costs only that refinement, not the import.\n */\ntype DataRouterProbe = { router?: { state?: { navigation?: { state?: string } } } } | null;\nconst NO_DATA_ROUTER = createContext<DataRouterProbe>(null);\nconst DataRouterContext: Context<DataRouterProbe> = readDataRouterContext();\n\n/**\n * A static member read (so a bundler still tree-shakes the namespace), inside a `try`:\n * a test's `vi.mock(\"react-router\", () => ({ … }))` without the original module throws\n * on ANY export it does not define, and it threw here at import (keksdose, 0.25.0) —\n * the hook then runs without the refinement, as on a router without the context.\n */\nfunction readDataRouterContext(): Context<DataRouterProbe> {\n  try {\n    return (\n      (ReactRouter as unknown as { UNSAFE_DataRouterContext?: Context<DataRouterProbe> }).UNSAFE_DataRouterContext ??\n      NO_DATA_ROUTER\n    );\n  } catch {\n    return NO_DATA_ROUTER;\n  }\n}\n\n/**\n * One write: `change` edits the queued query in place and says whether a param it\n * changed asks for its own entry. The navigation goes out at once — a lone write\n * behaves exactly as before, and a test can assert right after `act` — carrying the\n * whole queued query, so it includes every write before it.\n *\n * History, per tick (the writes one handler makes before a microtask runs):\n *  - the FIRST write that asks to push pushes; every later write in the tick REPLACES\n *    that entry, so a handler that sets four params adds one entry, and Back undoes\n *    all four at once — they were one change;\n *  - a write that asks to replace, before any push, rewrites the entry it found;\n *  - so mixed modes combine as \"push if any write asked to push\", which keeps both\n *    promises: a push-mode param's change is undone by Back, and a replace-mode param\n *    never adds an entry of its own (it rides on the one the push made). A replace\n *    write ahead of a push stays on the entry it rewrote, as it would one tick apart.\n *  - a write that changes nothing has no say, and sends nothing.\n */\nfunction writeQuery(\n  location: Location,\n  navigate: NavigateFunction,\n  dataRouter: DataRouterProbe,\n  change: (params: URLSearchParams) => boolean,\n): void {\n  let queued = queuedByLocation.get(location);\n  if (!queued) {\n    queued = {\n      params: new URLSearchParams(location.search),\n      state: location.state,\n      pushedThisTick: false,\n      lastPushed: false,\n    };\n    queuedByLocation.set(location, queued);\n  }\n  const before = queued.params.toString();\n  const wantsPush = change(queued.params);\n  const search = queued.params.toString();\n  if (search === before) return;\n\n  // A data router still loading our push has not written it to the history yet: a\n  // replace now would cancel it. Push again — the new navigation takes its place.\n  const loading = (dataRouter?.router?.state?.navigation?.state ?? \"idle\") !== \"idle\";\n  const push = (queued.lastPushed && loading) || (wantsPush && !queued.pushedThisTick);\n  if (push) {\n    queued.state = null;\n    if (!queued.pushedThisTick) {\n      queued.pushedThisTick = true;\n      const record = queued;\n      queueMicrotask(() => {\n        record.pushedThisTick = false;\n      });\n    }\n  }\n  queued.lastPushed = push;\n  void navigate(`?${search}`, push ? undefined : { replace: true, state: carriedState(queued.state) });\n}\n\n/** The rendered query, and a write that composes with every other one on the router. */\nfunction useQueryWriter(): [URLSearchParams, (change: (params: URLSearchParams) => boolean) => void] {\n  const location = useLocation();\n  const navigate = useNavigate();\n  const dataRouter = useContext(DataRouterContext);\n  const params = useMemo(() => new URLSearchParams(location.search), [location.search]);\n  return [params, (change) => writeQuery(location, navigate, dataRouter, change)];\n}\n\n/* ── The hooks ───────────────────────────────────────────────────────────── */\n\n/**\n * One URL search param as React state: `const [view, setView] = useSearchParamState(\"view\", \"list\")`.\n *\n * Replaces the hand-rolled `setParams((prev) => { const p = new URLSearchParams(prev);\n * …set/delete…; return p })` blocks that keksdose had in a dozen pages and kastlan ported\n * as its own copy of this hook (shared/hooks/use-search-param-state.ts, both apps). The\n * kit's version takes the DEFAULT as an argument rather than inside `parse`, so the\n * two rules that follow from it cannot be forgotten at a call site:\n *\n * * an absent or unparseable param reads as the default, and\n * * setting the default removes the param — the default view is the clean URL.\n *\n * Every other param in the query string is left as it is.\n *\n * **Setters compose** (0.25, keksdose live #378): setters called in a row — of one hook,\n * or of several hooks under the same router — each build on the write before them, so\n * `setStatus(\"open\"); setNs(\"legal\")` in one handler leaves both in the URL. react-\n * router's own `setSearchParams(updater)` does not: it hands every updater the params of\n * the render, so the last call used to write the others' old values back. The tick's\n * writes add at most one history entry; see `history`. When the params belong\n * together, {@link useSearchParamsState} writes them with one setter. A functional\n * update receives the value as the writes before it left it.\n *\n * Requires a react-router Router.\n */\nexport function useSearchParamState<T = string>(\n  key: string,\n  defaultValue: T,\n  options: SearchParamStateOptions<T> = {},\n): [T, (next: Updater<T>) => void] {\n  const [params, write] = useQueryWriter();\n  const rule = paramRule(key, defaultValue, options);\n  const value = readParam(params, rule);\n\n  const setValue = (next: Updater<T>) =>\n    write((query) => {\n      // Resolved against the queued query, not the render: a second update in the same\n      // handler sees the first one's result, as React's own functional updates do.\n      const resolved = typeof next === \"function\" ? (next as (prev: T) => T)(readParam(query, rule)) : next;\n      return putParam(query, rule, resolved) === true;\n    });\n\n  return [value, setValue];\n}\n\n/** One field of {@link useSearchParamsState}: its default, and the single hook's options. */\nexport interface SearchParamField<T> extends SearchParamStateOptions<T> {\n  /** The value when the param is absent or does not parse; writing it removes the param. */\n  default: T;\n  /** The param's name in the URL. Default: the field's name (`namespace: { param: \"ns\" }`). */\n  param?: string;\n}\n\n/** The fields of {@link useSearchParamsState}, one per key of the value object. */\nexport type SearchParamFields<V> = { [K in keyof V]: SearchParamField<V[K]> };\n\n/** A partial value (fields left out — or `undefined` — stay as they are), or a function\n *  of the current value returning one. */\nexport type SearchParamsUpdate<V> = Partial<V> | ((prev: V) => Partial<V>);\n\n/**\n * Several URL search params as ONE state object, with one setter that writes them in\n * one navigation:\n *\n *     const [filter, setFilter] = useSearchParamsState({\n *       status: { default: \"all\" as ReviewStatus | \"all\", parse: toStatus },\n *       namespace: { param: \"ns\", default: \"all\" },\n *       query: { param: \"q\", default: \"\", history: \"replace\" },\n *     });\n *     <TranslationReviewPanel filter={filter} onFilterChange={setFilter} />\n *\n * keksdose live #378: a filter bar reports all its filters on every change, and four\n * single-param setters in a row clobbered each other (see {@link useSearchParamState},\n * whose setters now compose too). This is the shape that never could: one setter, one\n * write, every field's rules in one place.\n *\n * Each field takes what the single hook takes — `parse`, `serialize`, `history` /\n * `replace` — and its `default` (the clean URL, as there) and optional `param` name.\n * The setter takes a partial object or a function of the current one; fields it leaves\n * out, or sets to `undefined`, stay as they are, and keys that are not fields are\n * ignored, so a component's whole filter object can be handed over as it is. Its\n * history is the single hook's rule over the fields that change: one entry, pushed if\n * any of them asks to push, else the current entry rewritten. Setting what the URL\n * already says navigates nowhere.\n *\n * The value object keeps its identity while its params do not change, so it can sit in\n * a dependency array. Requires a react-router Router.\n */\nexport function useSearchParamsState<V extends object>(\n  fields: SearchParamFields<V>,\n): [V, (next: SearchParamsUpdate<V>) => void] {\n  const [params, write] = useQueryWriter();\n  const rules = (Object.keys(fields) as Array<keyof V & string>).map((name) => {\n    const field = fields[name];\n    return [name, paramRule(field.param ?? name, field.default, field)] as const;\n  });\n  const readAll = (query: URLSearchParams): V =>\n    Object.fromEntries(rules.map(([name, rule]) => [name, readParam(query, rule)])) as V;\n\n  // The fields' own params, not the whole query: another param changing (a tab, a\n  // dialog) leaves this object as it was. `fields` is a fresh literal every render;\n  // what it reads is the same while the params and the field names are.\n  const ownParams = JSON.stringify(rules.map(([name, rule]) => [name, params.getAll(rule.key)]));\n  // eslint-disable-next-line react-hooks/exhaustive-deps -- keyed on what the value is read from; see above\n  const values = useMemo(() => readAll(params), [ownParams]);\n\n  const setValues = (next: SearchParamsUpdate<V>) =>\n    write((query) => {\n      const patch = typeof next === \"function\" ? next(readAll(query)) : next;\n      let push = false;\n      for (const [name, rule] of rules) {\n        const value = patch[name];\n        if (value === undefined) continue;\n        if (putParam(query, rule as ParamRule<unknown>, value) === true) push = true;\n      }\n      return push;\n    });\n\n  return [values, setValues];\n}\n\n/**\n * The active tab in `?tab=` (or `key`), with the default tab as the clean URL, for the\n * kit's `Tabs`:\n *\n *     const [tab, setTab] = useTabParam(\"overview\", { tabs: [\"overview\", \"history\"] });\n *     <Tabs tabs={…} active={tab} onChange={setTab} />\n *\n * Switching tabs REPLACES the history entry — a tab is a view of this page, not a\n * place Back should step through. `tabs`, when given, turns a param naming no tab (a\n * renamed tab, an old link) into the default rather than into a blank panel.\n * kastlan's use-tab-param.ts, with the validation it did not have.\n */\nexport function useTabParam<T extends string>(\n  defaultTab: T,\n  options: { key?: string; tabs?: readonly T[] } = {},\n): [T, (tab: T) => void] {\n  const { key = \"tab\", tabs } = options;\n  return useSearchParamState<T>(key, defaultTab, {\n    parse: (raw) => (!tabs || (tabs as readonly string[]).includes(raw) ? (raw as T) : undefined),\n    history: \"replace\",\n  });\n}\n\n/** Where a dialog's open state lives: a param's presence (`\"edit\"` → `?edit=1`), or one\n *  value of a shared param (`{ key: \"dialog\", value: \"create-lease\" }`). */\nexport type DialogParam = string | { key: string; value: string };\n\n/** The route-state mark an opener leaves on the entry it pushes, so the close knows it\n *  may go BACK over it rather than add a second entry. */\nconst OPENED_BY_KIT = \"__uiKitDialogParam\";\n\n/**\n * A dialog's open state in the URL, for `Modal`'s `urlParam` and anything else that\n * opens one: `const [open, setOpen] = useDialogParam({ key: \"dialog\", value: \"create\" })`.\n *\n * * **Opening pushes** an entry, so the platform Back gesture closes the dialog — by\n *   leaving the entry — and Forward opens it again, like any other step.\n * * **Closing goes back** over that entry when this hook pushed it, so a closed dialog\n *   leaves no dead entry behind. A dialog that arrived OPEN (a deep link, a reload, a\n *   plain `<Link>` to it) has nothing of ours to go back over, and its close removes the\n *   param in place instead — Back from there leaves the page, as it should.\n *\n * That is why it is not `useSearchParamState`: going back is the only close that\n * leaves the history as it was before the dialog, and only the opener knows whether it\n * may.\n */\nexport function useDialogParam(param: DialogParam): [boolean, (open: boolean) => void] {\n  const { key, value } = typeof param === \"string\" ? { key: param, value: \"1\" } : param;\n  const [params, setParams] = useSearchParams();\n  const location = useLocation();\n  const navigate = useNavigate();\n  const open = typeof param === \"string\" ? params.has(key) : params.get(key) === value;\n  const mark = `${key}=${value}`;\n\n  const setOpen = (next: boolean) => {\n    if (next === open) return;\n    const state = carriedState(location.state);\n    if (next) {\n      setParams(\n        (prev) => {\n          const p = new URLSearchParams(prev);\n          p.set(key, value);\n          return p;\n        },\n        { state: { ...state, [OPENED_BY_KIT]: mark } },\n      );\n      return;\n    }\n    if (state?.[OPENED_BY_KIT] === mark) {\n      void navigate(-1);\n      return;\n    }\n    setParams(\n      (prev) => {\n        const p = new URLSearchParams(prev);\n        p.delete(key);\n        return p;\n      },\n      { replace: true, state },\n    );\n  };\n\n  return [open, setOpen];\n}\n"],"mappings":"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","names":[]}

package/dist/i18n/defaults.d.ts

@@ -1,9 +1,9 @@
-import { cB as UiKitLabels } from '../feedback-DOwPu-Il.js';
+import { cB as UiKitLabels } from '../feedback-BXKH-ToU.js';
 import 'react';
 import '../components/tooltip.js';
 import '../hooks/use-anchored-rect.js';
 import '../lib/clipping.js';
-import '../data-table-labels-B7OdnM0S.js';
+import '../data-table-labels-Cdn1QS2k.js';
 import '../components/data-table-sort.js';
 import '../components/swipeable-row.js';
 import '../components/mini-calendar.js';

package/dist/i18n/german.d.ts

@@ -1,9 +1,9 @@
-import { cB as UiKitLabels } from '../feedback-DOwPu-Il.js';
+import { cB as UiKitLabels } from '../feedback-BXKH-ToU.js';
 import 'react';
 import '../components/tooltip.js';
 import '../hooks/use-anchored-rect.js';
 import '../lib/clipping.js';
-import '../data-table-labels-B7OdnM0S.js';
+import '../data-table-labels-Cdn1QS2k.js';
 import '../components/data-table-sort.js';
 import '../components/swipeable-row.js';
 import '../components/mini-calendar.js';

package/dist/i18n/german.js

@@ -694,6 +694,7 @@ function germanLabels(numberLocale) {
       roleOf: (column) => `Was enth\xE4lt die Spalte \u201E${column}\u201C?`,
       ignore: "Ignorieren",
       requiredRole: (role) => `${role} (erforderlich)`,
+      requiredRoleShort: (role) => `${role} *`,
       previewOf: (shown, total) => shown === 1 ? `Die erste von ${n(total)} Zeilen` : `Die ersten ${n(shown)} von ${n(total)} Zeilen`,
       // `roles` arrives joined with "oder" ("Soll oder Haben").
       oneOf: (roles) => `entweder ${roles}`,
@@ -745,7 +746,13 @@ function germanLabels(numberLocale) {
       readOnly: "Sie k\xF6nnen diese Sprache lesen, aber nicht pr\xFCfen.",
       scope: (areas) => `Ihre Pr\xFCfung ist beschr\xE4nkt auf: ${areas}.`,
       exportCorrections: (count) => `Korrekturen exportieren (${n(count)})`,
-      failed: "Das hat nicht geklappt. Bitte erneut versuchen."
+      failed: "Das hat nicht geklappt. Bitte erneut versuchen.",
+      approvedToast: (count) => count === 1 ? "Text best\xE4tigt" : `${n(count)} Texte best\xE4tigt`,
+      groupCount: (unreviewed, total) => `${n(unreviewed)} ungepr\xFCft / ${n(total)}`,
+      approveGroup: (count) => `Ungepr\xFCfte best\xE4tigen (${n(count)})`,
+      // The group's name quoted, as `columnMapper.roleOf`'s column: it is often a key
+      // ("billing"), which unquoted would read as part of the sentence.
+      confirmGroup: (count, group) => count === 1 ? `Den ungepr\xFCften Text in \u201E${group}\u201C best\xE4tigen?` : `Alle ${n(count)} ungepr\xFCften Texte in \u201E${group}\u201C best\xE4tigen \u2013 auch die nicht angezeigten?`
     }
   };
 }