@eifi1/ui-kit 0.32.1 → 0.33.0

package/dist/components/use-table-state.d.ts

@@ -1,4 +1,15 @@
 import 'react';
 import './data-table-sort.js';
-export { I as DEFAULT_PERSIST_PREFIX, T as TableUrlState, k as TableUrlStateProps, l as TableUrlSync, U as UseTableUrlStateOptions, m as UseTableUrlStateReturn, w as readTableUrlState, J as useTableState, E as useTableUrlState } from '../data-table-labels-kpAAVi6g.js';
+export { I as DEFAULT_PERSIST_PREFIX, T as TableUrlState, k as TableUrlStateProps, l as TableUrlSync, U as UseTableUrlStateOptions, m as UseTableUrlStateReturn, w as readTableUrlState, J as useTableState, E as useTableUrlState } from '../data-table-labels-BJ5JE_X2.js';
 import './swipeable-row.js';
+import './status-dot.js';
+import './progress-bar.js';
+import './signed-amount.js';
+import './stat-tile.js';
+import './chip.js';
+import 'lucide-react';
+import './field-parts.js';
+import './tooltip.js';
+import '../hooks/use-anchored-rect.js';
+import '../lib/clipping.js';
+import './write-lock.js';

package/dist/components/user-avatar.d.ts

@@ -11,6 +11,7 @@ import './field-parts.js';
 import './tooltip.js';
 import '../hooks/use-anchored-rect.js';
 import '../lib/clipping.js';
+import './write-lock.js';
 
 /** Initials from a display name (first + last) or, failing that, an email —
  *  e.g. "Marcel Eifert" → "ME", "marcel@x.com" → "MA". App-agnostic.

package/dist/components/write-lock.d.ts

@@ -7,12 +7,62 @@ interface WriteLockLabels {
     reason: string;
 }
 declare const DEFAULT_WRITE_LOCK_LABELS: WriteLockLabels;
-/** What {@link useWriteLock} returns: whether commits are locked here, and why. */
+/**
+ * What kind of lock a source is (docs/billing-harmonization.md §12.36, ui-kit 0.33).
+ * `"demo"` (the read-only demo, `demo.writeLocked`) and `"billing"` (a lapsed plan,
+ * `billing.lockReason`) are the kit's; an app names its own — Kurvenschmiede's
+ * `"access"` (a curve shared to view) and `"customer"` (an account that owns nothing).
+ * A control exempts itself from a kind with {@link CommitScope}; a source without a
+ * kind is never exempted.
+ */
+type WriteLockKind = "demo" | "billing" | (string & {});
+/** One locked source, as the provider holds it: its kind and its one sentence. */
+interface WriteLockHold {
+    kind: WriteLockKind | undefined;
+    reason: ReactNode;
+}
+/**
+ * A control's opt-in to the lock — the type of every `commit` prop in the kit.
+ *
+ * - `true`: every lock refuses the control (a save, an add, an invite).
+ * - `{ except: [kinds] }`: every lock but those kinds. A billing lock leaves the
+ *   reader able to remove access, revoke sessions, delete the account and change their
+ *   own settings (§3.3, §12.13), so the kit's parts for those take
+ *   {@link COMMIT_EXCEPT_BILLING} built in, and an app's own controls of that sort do
+ *   too.
+ * - `false` or left out: no lock reaches it.
+ *
+ * Under a demo lock and a billing lock together, a control exempt from billing is
+ * still refused, with the demo's reason.
+ */
+type CommitScope = boolean | {
+    readonly except: readonly WriteLockKind[];
+};
+/** Every lock but billing's: the scope of an action a lapsed plan still allows — removing
+ *  access, the account's own settings, an operator's admin route (§12.13). One constant,
+ *  so the call sites read alike. */
+declare const COMMIT_EXCEPT_BILLING: {
+    readonly except: readonly ["billing"];
+};
+/**
+ * What {@link useWriteLock} returns: whether commits are locked here as a control with
+ * the scope asked for sees it, and why.
+ */
 interface WriteLock {
     locked: boolean;
-    /** The one sentence a locked commit shows in its tooltip. Always set while
-     *  `locked`; `undefined` when not. */
+    /** The one sentence a locked commit shows in its tooltip: the first hold in scope's.
+     *  Always set while `locked`; `undefined` when not. */
     reason: ReactNode | undefined;
+    /** The first hold in scope's kind; `undefined` while unlocked, or for a source that
+     *  names none. */
+    kind: WriteLockKind | undefined;
+    /**
+     * EVERY locked source the provider holds, in the order the server refuses them
+     * (§12.3: the demo's 403 before billing's 402) — unfiltered by the scope, for code
+     * that must know what else locks (a toast that names the plan, a swipe plan). Empty
+     * while the provider is unlocked.
+     */
+    holds: readonly WriteLockHold[];
 }
 interface WriteLockProviderProps {
     /** Commits below are locked. `false` unlocks a subtree under an outer lock. */
@@ -23,6 +73,17 @@ interface WriteLockProviderProps {
      * already translated. Left out: `labels.reason`.
      */
     reason?: ReactNode;
+    /** What kind of lock this is — `"demo"`, `"billing"` or the app's own (see
+     *  {@link WriteLockKind}), for a provider of one source. Left out, no control can be
+     *  exempt from it. */
+    kind?: WriteLockKind;
+    /**
+     * Every locked source, in refusal order — what `combineWriteLocks` answers, so
+     * `<WriteLockProvider {...combineWriteLocks([...])}>` carries them. Given while
+     * `locked`, it wins over `kind` and `reason`; a hold without a reason takes
+     * `labels.reason`.
+     */
+    holds?: readonly WriteLockHold[];
     labels?: Partial<WriteLockLabels>;
     children?: ReactNode;
 }
@@ -50,19 +111,46 @@ interface WriteLockProviderProps {
  * {@link useWriteLock} and disables itself. The lock is a courtesy, not a guard: the
  * server still refuses the write.
  *
+ * **A lock says its source** (0.33, docs/billing-harmonization.md §12.36). A lapsed
+ * plan locks creating and changing, but not removing access or the account's own
+ * settings (§3.3, §12.13), and the kit's parts for those hard-coded `commit` — so
+ * kastlan's app-wide lock locked a member's own sign-out everywhere. Each source now
+ * has a kind, the provider holds every locked one in order (`holds`, from
+ * `combineWriteLocks`), and a control's `commit` may name the kinds it is exempt from
+ * ({@link CommitScope}). The kit's parts follow §3.3 and §12.13 by themselves.
+ *
  * Nested providers: the nearest wins, so an inner `locked={false}` reopens a section
- * the caller may write (a viewer's own notes on a shared curve), and an inner lock
- * with its own reason (Kurvenschmiede's owner lock beside the viewer lock) overrides
- * the outer one's sentence.
+ * the caller may write (a viewer's own notes on a shared curve) — every source at
+ * once — and an inner lock with its own reason (Kurvenschmiede's owner lock beside the
+ * viewer lock) overrides the outer one's sentence and its holds.
+ */
+declare function WriteLockProvider({ locked, reason, kind, holds, labels, children }: WriteLockProviderProps): react.JSX.Element;
+/**
+ * The lock as a control with `scope` sees it — {@link useWriteLock}'s answer, pure, for
+ * a scope known only at call time: `useConfirm` reads the CALLER's lock when it is
+ * called, and applies each `confirm({ commit })`'s own scope to it when it runs.
+ *
+ * `undefined` and `false` see no lock (a control without `commit`); `true` sees the
+ * lock as it is; `{ except }` sees the first hold of another kind, with its reason
+ * and kind. `holds` is passed on unfiltered.
+ */
+declare function writeLockFor(lock: WriteLock, scope: CommitScope | undefined): WriteLock;
+/**
+ * The nearest {@link WriteLockProvider}'s lock, as a control with `scope` sees it —
+ * unlocked with no provider. Left out, the scope is `true`: every lock.
+ *
+ * For code that must KNOW rather than a control that opts in: a toast that says why,
+ * a swipe plan that leaves an action out, a hand-rolled toggle that disables itself.
+ * `useWriteLock(COMMIT_EXCEPT_BILLING)` answers "would a lapsed plan's lock refuse me?"
+ * as a removal sees it — what keksdose's `useWriteLockKind() !== "billing"` asked.
  */
-declare function WriteLockProvider({ locked, reason, labels, children }: WriteLockProviderProps): react.JSX.Element;
-/** The nearest {@link WriteLockProvider}'s lock; unlocked with no provider. */
-declare function useWriteLock(): WriteLock;
+declare function useWriteLock(scope?: CommitScope): WriteLock;
 /**
  * The `disabledReason` a control with `commit` should use: the lock's reason while
- * locked — it wins over the control's own, since it is the answer to the question the
- * hover is asking — else the control's own. Internal to the kit's commit controls.
+ * the lock refuses this scope — it wins over the control's own, since it is the answer
+ * to the question the hover is asking — else the control's own. Internal to the kit's
+ * commit controls.
  */
-declare function useCommitReason(commit: boolean | undefined, own: ReactNode): ReactNode;
+declare function useCommitReason(commit: CommitScope | undefined, own: ReactNode): ReactNode;
 
-export { DEFAULT_WRITE_LOCK_LABELS, type WriteLock, type WriteLockLabels, WriteLockProvider, type WriteLockProviderProps, useCommitReason, useWriteLock };
+export { COMMIT_EXCEPT_BILLING, type CommitScope, DEFAULT_WRITE_LOCK_LABELS, type WriteLock, type WriteLockHold, type WriteLockKind, type WriteLockLabels, WriteLockProvider, type WriteLockProviderProps, useCommitReason, useWriteLock, writeLockFor };

package/dist/components/write-lock.js

@@ -5,29 +5,53 @@ import { useKitLabels } from "../i18n/kit-labels.js";
 const DEFAULT_WRITE_LOCK_LABELS = {
   reason: "You can view this but not change it."
 };
-const UNLOCKED = { locked: false, reason: void 0 };
+const COMMIT_EXCEPT_BILLING = { except: ["billing"] };
+const NO_HOLDS = [];
+const UNLOCKED = { locked: false, reason: void 0, kind: void 0, holds: NO_HOLDS };
 const WriteLockContext = createContext(UNLOCKED);
-function WriteLockProvider({ locked, reason, labels, children }) {
+function given(reason) {
+  return reason !== void 0 && reason !== null && reason !== false && reason !== "";
+}
+function WriteLockProvider({ locked, reason, kind, holds, labels, children }) {
   const fallback = useKitLabels("writeLock", DEFAULT_WRITE_LOCK_LABELS, labels).reason;
-  const given = reason !== void 0 && reason !== null && reason !== false && reason !== "";
-  const resolved = locked ? given ? reason : fallback : void 0;
-  const value = useMemo(
-    () => locked ? { locked: true, reason: resolved } : UNLOCKED,
-    [locked, resolved]
-  );
+  const several = locked && holds !== void 0 && holds.length > 0 ? holds : void 0;
+  const firstKind = several ? several[0].kind : kind;
+  const firstGiven = several ? several[0].reason : reason;
+  const firstReason = given(firstGiven) ? firstGiven : fallback;
+  const many = several && several.length > 1 ? several : void 0;
+  const value = useMemo(() => {
+    if (!locked) return UNLOCKED;
+    const all = many ? many.map((hold) => ({ kind: hold.kind, reason: given(hold.reason) ? hold.reason : fallback })) : [{ kind: firstKind, reason: firstReason }];
+    return { locked: true, reason: firstReason, kind: firstKind, holds: all };
+  }, [locked, many, firstKind, firstReason, fallback]);
   return /* @__PURE__ */ jsx(WriteLockContext.Provider, { value, children });
 }
-function useWriteLock() {
-  return useContext(WriteLockContext);
+function inScope(hold, scope) {
+  if (scope === true) return true;
+  if (scope === false) return false;
+  return hold.kind === void 0 || !scope.except.includes(hold.kind);
+}
+function writeLockFor(lock, scope) {
+  if (!lock.locked || scope === true) return lock;
+  const holds = lock.holds.length > 0 ? lock.holds : [{ kind: lock.kind, reason: lock.reason }];
+  const first = scope === void 0 ? void 0 : holds.find((hold) => inScope(hold, scope));
+  if (!first) return { ...UNLOCKED, holds: lock.holds };
+  if (first === holds[0]) return lock;
+  return { locked: true, reason: first.reason, kind: first.kind, holds: lock.holds };
+}
+function useWriteLock(scope = true) {
+  return writeLockFor(useContext(WriteLockContext), scope);
 }
 function useCommitReason(commit, own) {
-  const lock = useWriteLock();
-  return commit && lock.locked ? lock.reason : own;
+  const lock = writeLockFor(useContext(WriteLockContext), commit);
+  return lock.locked ? lock.reason : own;
 }
 export {
+  COMMIT_EXCEPT_BILLING,
   DEFAULT_WRITE_LOCK_LABELS,
   WriteLockProvider,
   useCommitReason,
-  useWriteLock
+  useWriteLock,
+  writeLockFor
 };
 //# sourceMappingURL=write-lock.js.map

package/dist/components/write-lock.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/components/write-lock.tsx"],"sourcesContent":["import { createContext, useContext, useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport { useKitLabels } from \"../i18n/kit-labels\";\n\n/** The words {@link WriteLockProvider} renders on its own behalf. */\nexport interface WriteLockLabels {\n  /** The tooltip of a locked commit when the provider gives no `reason`. */\n  reason: string;\n}\n\nexport const DEFAULT_WRITE_LOCK_LABELS: WriteLockLabels = {\n  reason: \"You can view this but not change it.\",\n};\n\n/** What {@link useWriteLock} returns: whether commits are locked here, and why. */\nexport interface WriteLock {\n  locked: boolean;\n  /** The one sentence a locked commit shows in its tooltip. Always set while\n   *  `locked`; `undefined` when not. */\n  reason: ReactNode | undefined;\n}\n\nconst UNLOCKED: WriteLock = { locked: false, reason: undefined };\n\nconst WriteLockContext = createContext<WriteLock>(UNLOCKED);\n\nexport interface WriteLockProviderProps {\n  /** Commits below are locked. `false` unlocks a subtree under an outer lock. */\n  locked: boolean;\n  /**\n   * The one sentence that says why — \"Shared with you to read\", \"Read-only demo —\n   * saving is disabled\", \"A customer account cannot create curves\". The app's policy,\n   * already translated. Left out: `labels.reason`.\n   */\n  reason?: ReactNode;\n  labels?: Partial<WriteLockLabels>;\n  children?: ReactNode;\n}\n\n/**\n * The read-only lock — **everything renders; only the commit is locked.**\n *\n * keksdose (features/budgets/write-lock.tsx, the read-only demo budget) and\n * Kurvenschmiede (features/sharing/write-lock.tsx, a curve shared to view, a customer\n * account that owns nothing) each built the same `SaveGuard`: the page, its tabs,\n * forms and dialogs render exactly as for an owner, because a viewer looking at half\n * a page is not looking at what they were sent; what changes is that the control\n * that SAVES is off and says why on hover or focus. Both wrapped each Save in a\n * Tooltip and forced a native `disabled` on it — out of the tab order, so the reason\n * never reached a keyboard — and both had to remember it at thirty call sites.\n *\n * Here the page mounts one provider and each commit control opts in with `commit`\n * ({@link Button}, {@link IconButton}, {@link FormActions}): under a lock it takes the\n * kit's `disabledReason` path with this reason — `aria-disabled` and focusable,\n * every activation swallowed, the reason in the kit Tooltip and its description.\n *\n * Who is locked is the app's: the provider takes a boolean, never a role. Fields stay\n * editable — nothing in them reaches the server until the commit is pressed, and a\n * form you cannot fill in is not a demo of the form (keksdose accounts-page). A\n * control that IS its own commit (a toggle that saves on change) reads\n * {@link useWriteLock} and disables itself. The lock is a courtesy, not a guard: the\n * server still refuses the write.\n *\n * Nested providers: the nearest wins, so an inner `locked={false}` reopens a section\n * the caller may write (a viewer's own notes on a shared curve), and an inner lock\n * with its own reason (Kurvenschmiede's owner lock beside the viewer lock) overrides\n * the outer one's sentence.\n */\nexport function WriteLockProvider({ locked, reason, labels, children }: WriteLockProviderProps) {\n  // The `writeLock` namespace: prop > `<UiKitProvider labels>` > English.\n  const fallback = useKitLabels(\"writeLock\", DEFAULT_WRITE_LOCK_LABELS, labels).reason;\n  // `null`/`\"\"`/`false` count as \"no reason given\": a lock whose tooltip is empty\n  // would be a disabled button that cannot say why, the thing this replaces.\n  const given = reason !== undefined && reason !== null && reason !== false && reason !== \"\";\n  const resolved = locked ? (given ? reason : fallback) : undefined;\n  const value = useMemo<WriteLock>(\n    () => (locked ? { locked: true, reason: resolved } : UNLOCKED),\n    [locked, resolved],\n  );\n  return <WriteLockContext.Provider value={value}>{children}</WriteLockContext.Provider>;\n}\n\n/** The nearest {@link WriteLockProvider}'s lock; unlocked with no provider. */\nexport function useWriteLock(): WriteLock {\n  return useContext(WriteLockContext);\n}\n\n/**\n * The `disabledReason` a control with `commit` should use: the lock's reason while\n * locked — it wins over the control's own, since it is the answer to the question the\n * hover is asking — else the control's own. Internal to the kit's commit controls.\n */\nexport function useCommitReason(commit: boolean | undefined, own: ReactNode): ReactNode {\n  const lock = useWriteLock();\n  return commit && lock.locked ? lock.reason : own;\n}\n"],"mappings":";AA+ES;AA/ET,SAAS,eAAe,YAAY,eAAe;AAEnD,SAAS,oBAAoB;AAQtB,MAAM,4BAA6C;AAAA,EACxD,QAAQ;AACV;AAUA,MAAM,WAAsB,EAAE,QAAQ,OAAO,QAAQ,OAAU;AAE/D,MAAM,mBAAmB,cAAyB,QAAQ;AA4CnD,SAAS,kBAAkB,EAAE,QAAQ,QAAQ,QAAQ,SAAS,GAA2B;AAE9F,QAAM,WAAW,aAAa,aAAa,2BAA2B,MAAM,EAAE;AAG9E,QAAM,QAAQ,WAAW,UAAa,WAAW,QAAQ,WAAW,SAAS,WAAW;AACxF,QAAM,WAAW,SAAU,QAAQ,SAAS,WAAY;AACxD,QAAM,QAAQ;AAAA,IACZ,MAAO,SAAS,EAAE,QAAQ,MAAM,QAAQ,SAAS,IAAI;AAAA,IACrD,CAAC,QAAQ,QAAQ;AAAA,EACnB;AACA,SAAO,oBAAC,iBAAiB,UAAjB,EAA0B,OAAe,UAAS;AAC5D;AAGO,SAAS,eAA0B;AACxC,SAAO,WAAW,gBAAgB;AACpC;AAOO,SAAS,gBAAgB,QAA6B,KAA2B;AACtF,QAAM,OAAO,aAAa;AAC1B,SAAO,UAAU,KAAK,SAAS,KAAK,SAAS;AAC/C;","names":[]}
+{"version":3,"sources":["../../src/components/write-lock.tsx"],"sourcesContent":["import { createContext, useContext, useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport { useKitLabels } from \"../i18n/kit-labels\";\n\n/** The words {@link WriteLockProvider} renders on its own behalf. */\nexport interface WriteLockLabels {\n  /** The tooltip of a locked commit when the provider gives no `reason`. */\n  reason: string;\n}\n\nexport const DEFAULT_WRITE_LOCK_LABELS: WriteLockLabels = {\n  reason: \"You can view this but not change it.\",\n};\n\n/**\n * What kind of lock a source is (docs/billing-harmonization.md §12.36, ui-kit 0.33).\n * `\"demo\"` (the read-only demo, `demo.writeLocked`) and `\"billing\"` (a lapsed plan,\n * `billing.lockReason`) are the kit's; an app names its own — Kurvenschmiede's\n * `\"access\"` (a curve shared to view) and `\"customer\"` (an account that owns nothing).\n * A control exempts itself from a kind with {@link CommitScope}; a source without a\n * kind is never exempted.\n */\nexport type WriteLockKind = \"demo\" | \"billing\" | (string & {});\n\n/** One locked source, as the provider holds it: its kind and its one sentence. */\nexport interface WriteLockHold {\n  kind: WriteLockKind | undefined;\n  reason: ReactNode;\n}\n\n/**\n * A control's opt-in to the lock — the type of every `commit` prop in the kit.\n *\n * - `true`: every lock refuses the control (a save, an add, an invite).\n * - `{ except: [kinds] }`: every lock but those kinds. A billing lock leaves the\n *   reader able to remove access, revoke sessions, delete the account and change their\n *   own settings (§3.3, §12.13), so the kit's parts for those take\n *   {@link COMMIT_EXCEPT_BILLING} built in, and an app's own controls of that sort do\n *   too.\n * - `false` or left out: no lock reaches it.\n *\n * Under a demo lock and a billing lock together, a control exempt from billing is\n * still refused, with the demo's reason.\n */\nexport type CommitScope = boolean | { readonly except: readonly WriteLockKind[] };\n\n/** Every lock but billing's: the scope of an action a lapsed plan still allows — removing\n *  access, the account's own settings, an operator's admin route (§12.13). One constant,\n *  so the call sites read alike. */\nexport const COMMIT_EXCEPT_BILLING = { except: [\"billing\"] } as const;\n\n/**\n * What {@link useWriteLock} returns: whether commits are locked here as a control with\n * the scope asked for sees it, and why.\n */\nexport interface WriteLock {\n  locked: boolean;\n  /** The one sentence a locked commit shows in its tooltip: the first hold in scope's.\n   *  Always set while `locked`; `undefined` when not. */\n  reason: ReactNode | undefined;\n  /** The first hold in scope's kind; `undefined` while unlocked, or for a source that\n   *  names none. */\n  kind: WriteLockKind | undefined;\n  /**\n   * EVERY locked source the provider holds, in the order the server refuses them\n   * (§12.3: the demo's 403 before billing's 402) — unfiltered by the scope, for code\n   * that must know what else locks (a toast that names the plan, a swipe plan). Empty\n   * while the provider is unlocked.\n   */\n  holds: readonly WriteLockHold[];\n}\n\nconst NO_HOLDS: readonly WriteLockHold[] = [];\n\nconst UNLOCKED: WriteLock = { locked: false, reason: undefined, kind: undefined, holds: NO_HOLDS };\n\nconst WriteLockContext = createContext<WriteLock>(UNLOCKED);\n\nexport interface WriteLockProviderProps {\n  /** Commits below are locked. `false` unlocks a subtree under an outer lock. */\n  locked: boolean;\n  /**\n   * The one sentence that says why — \"Shared with you to read\", \"Read-only demo —\n   * saving is disabled\", \"A customer account cannot create curves\". The app's policy,\n   * already translated. Left out: `labels.reason`.\n   */\n  reason?: ReactNode;\n  /** What kind of lock this is — `\"demo\"`, `\"billing\"` or the app's own (see\n   *  {@link WriteLockKind}), for a provider of one source. Left out, no control can be\n   *  exempt from it. */\n  kind?: WriteLockKind;\n  /**\n   * Every locked source, in refusal order — what `combineWriteLocks` answers, so\n   * `<WriteLockProvider {...combineWriteLocks([...])}>` carries them. Given while\n   * `locked`, it wins over `kind` and `reason`; a hold without a reason takes\n   * `labels.reason`.\n   */\n  holds?: readonly WriteLockHold[];\n  labels?: Partial<WriteLockLabels>;\n  children?: ReactNode;\n}\n\n// `null`/`\"\"`/`false` count as \"no reason given\": a lock whose tooltip is empty would be\n// a disabled button that cannot say why, the thing this replaces.\nfunction given(reason: ReactNode): boolean {\n  return reason !== undefined && reason !== null && reason !== false && reason !== \"\";\n}\n\n/**\n * The read-only lock — **everything renders; only the commit is locked.**\n *\n * keksdose (features/budgets/write-lock.tsx, the read-only demo budget) and\n * Kurvenschmiede (features/sharing/write-lock.tsx, a curve shared to view, a customer\n * account that owns nothing) each built the same `SaveGuard`: the page, its tabs,\n * forms and dialogs render exactly as for an owner, because a viewer looking at half\n * a page is not looking at what they were sent; what changes is that the control\n * that SAVES is off and says why on hover or focus. Both wrapped each Save in a\n * Tooltip and forced a native `disabled` on it — out of the tab order, so the reason\n * never reached a keyboard — and both had to remember it at thirty call sites.\n *\n * Here the page mounts one provider and each commit control opts in with `commit`\n * ({@link Button}, {@link IconButton}, {@link FormActions}): under a lock it takes the\n * kit's `disabledReason` path with this reason — `aria-disabled` and focusable,\n * every activation swallowed, the reason in the kit Tooltip and its description.\n *\n * Who is locked is the app's: the provider takes a boolean, never a role. Fields stay\n * editable — nothing in them reaches the server until the commit is pressed, and a\n * form you cannot fill in is not a demo of the form (keksdose accounts-page). A\n * control that IS its own commit (a toggle that saves on change) reads\n * {@link useWriteLock} and disables itself. The lock is a courtesy, not a guard: the\n * server still refuses the write.\n *\n * **A lock says its source** (0.33, docs/billing-harmonization.md §12.36). A lapsed\n * plan locks creating and changing, but not removing access or the account's own\n * settings (§3.3, §12.13), and the kit's parts for those hard-coded `commit` — so\n * kastlan's app-wide lock locked a member's own sign-out everywhere. Each source now\n * has a kind, the provider holds every locked one in order (`holds`, from\n * `combineWriteLocks`), and a control's `commit` may name the kinds it is exempt from\n * ({@link CommitScope}). The kit's parts follow §3.3 and §12.13 by themselves.\n *\n * Nested providers: the nearest wins, so an inner `locked={false}` reopens a section\n * the caller may write (a viewer's own notes on a shared curve) — every source at\n * once — and an inner lock with its own reason (Kurvenschmiede's owner lock beside the\n * viewer lock) overrides the outer one's sentence and its holds.\n */\nexport function WriteLockProvider({ locked, reason, kind, holds, labels, children }: WriteLockProviderProps) {\n  // The `writeLock` namespace: prop > `<UiKitProvider labels>` > English.\n  const fallback = useKitLabels(\"writeLock\", DEFAULT_WRITE_LOCK_LABELS, labels).reason;\n  // `holds` wins while it has any; otherwise this provider is one source of its own.\n  const several = locked && holds !== undefined && holds.length > 0 ? holds : undefined;\n  const firstKind = several ? several[0].kind : kind;\n  const firstGiven = several ? several[0].reason : reason;\n  const firstReason = given(firstGiven) ? firstGiven : fallback;\n  // Memoised on the first hold's kind and sentence — the strings an app passes — so a\n  // one-source lock keeps one context value across renders; a list of several is\n  // memoised on its own identity.\n  const many = several && several.length > 1 ? several : undefined;\n  const value = useMemo<WriteLock>(() => {\n    if (!locked) return UNLOCKED;\n    const all = many\n      ? many.map((hold) => ({ kind: hold.kind, reason: given(hold.reason) ? hold.reason : fallback }))\n      : [{ kind: firstKind, reason: firstReason }];\n    return { locked: true, reason: firstReason, kind: firstKind, holds: all };\n  }, [locked, many, firstKind, firstReason, fallback]);\n  return <WriteLockContext.Provider value={value}>{children}</WriteLockContext.Provider>;\n}\n\n/**\n * Whether a hold refuses a control with this scope: `true` refuses with every hold,\n * `{ except }` with every hold whose kind it does not name. A hold with no kind is\n * never exempted — an app that forgot to name its source must not reopen by accident.\n */\nfunction inScope(hold: WriteLockHold, scope: CommitScope): boolean {\n  if (scope === true) return true;\n  if (scope === false) return false;\n  return hold.kind === undefined || !scope.except.includes(hold.kind);\n}\n\n/**\n * The lock as a control with `scope` sees it — {@link useWriteLock}'s answer, pure, for\n * a scope known only at call time: `useConfirm` reads the CALLER's lock when it is\n * called, and applies each `confirm({ commit })`'s own scope to it when it runs.\n *\n * `undefined` and `false` see no lock (a control without `commit`); `true` sees the\n * lock as it is; `{ except }` sees the first hold of another kind, with its reason\n * and kind. `holds` is passed on unfiltered.\n */\nexport function writeLockFor(lock: WriteLock, scope: CommitScope | undefined): WriteLock {\n  if (!lock.locked || scope === true) return lock;\n  // A lock built by hand (a test's, an app's own context) may carry no holds: it is\n  // then the one source it describes.\n  const holds = lock.holds.length > 0 ? lock.holds : [{ kind: lock.kind, reason: lock.reason }];\n  const first = scope === undefined ? undefined : holds.find((hold) => inScope(hold, scope));\n  if (!first) return { ...UNLOCKED, holds: lock.holds };\n  // The first in scope is the provider's own first: the lock as it is, same object.\n  if (first === holds[0]) return lock;\n  return { locked: true, reason: first.reason, kind: first.kind, holds: lock.holds };\n}\n\n/**\n * The nearest {@link WriteLockProvider}'s lock, as a control with `scope` sees it —\n * unlocked with no provider. Left out, the scope is `true`: every lock.\n *\n * For code that must KNOW rather than a control that opts in: a toast that says why,\n * a swipe plan that leaves an action out, a hand-rolled toggle that disables itself.\n * `useWriteLock(COMMIT_EXCEPT_BILLING)` answers \"would a lapsed plan's lock refuse me?\"\n * as a removal sees it — what keksdose's `useWriteLockKind() !== \"billing\"` asked.\n */\nexport function useWriteLock(scope: CommitScope = true): WriteLock {\n  return writeLockFor(useContext(WriteLockContext), scope);\n}\n\n/**\n * The `disabledReason` a control with `commit` should use: the lock's reason while\n * the lock refuses this scope — it wins over the control's own, since it is the answer\n * to the question the hover is asking — else the control's own. Internal to the kit's\n * commit controls.\n */\nexport function useCommitReason(commit: CommitScope | undefined, own: ReactNode): ReactNode {\n  const lock = writeLockFor(useContext(WriteLockContext), commit);\n  return lock.locked ? lock.reason : own;\n}\n"],"mappings":";AAoKS;AApKT,SAAS,eAAe,YAAY,eAAe;AAEnD,SAAS,oBAAoB;AAQtB,MAAM,4BAA6C;AAAA,EACxD,QAAQ;AACV;AAqCO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,SAAS,EAAE;AAuB3D,MAAM,WAAqC,CAAC;AAE5C,MAAM,WAAsB,EAAE,QAAQ,OAAO,QAAQ,QAAW,MAAM,QAAW,OAAO,SAAS;AAEjG,MAAM,mBAAmB,cAAyB,QAAQ;AA4B1D,SAAS,MAAM,QAA4B;AACzC,SAAO,WAAW,UAAa,WAAW,QAAQ,WAAW,SAAS,WAAW;AACnF;AAuCO,SAAS,kBAAkB,EAAE,QAAQ,QAAQ,MAAM,OAAO,QAAQ,SAAS,GAA2B;AAE3G,QAAM,WAAW,aAAa,aAAa,2BAA2B,MAAM,EAAE;AAE9E,QAAM,UAAU,UAAU,UAAU,UAAa,MAAM,SAAS,IAAI,QAAQ;AAC5E,QAAM,YAAY,UAAU,QAAQ,CAAC,EAAE,OAAO;AAC9C,QAAM,aAAa,UAAU,QAAQ,CAAC,EAAE,SAAS;AACjD,QAAM,cAAc,MAAM,UAAU,IAAI,aAAa;AAIrD,QAAM,OAAO,WAAW,QAAQ,SAAS,IAAI,UAAU;AACvD,QAAM,QAAQ,QAAmB,MAAM;AACrC,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,MAAM,OACR,KAAK,IAAI,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,QAAQ,MAAM,KAAK,MAAM,IAAI,KAAK,SAAS,SAAS,EAAE,IAC7F,CAAC,EAAE,MAAM,WAAW,QAAQ,YAAY,CAAC;AAC7C,WAAO,EAAE,QAAQ,MAAM,QAAQ,aAAa,MAAM,WAAW,OAAO,IAAI;AAAA,EAC1E,GAAG,CAAC,QAAQ,MAAM,WAAW,aAAa,QAAQ,CAAC;AACnD,SAAO,oBAAC,iBAAiB,UAAjB,EAA0B,OAAe,UAAS;AAC5D;AAOA,SAAS,QAAQ,MAAqB,OAA6B;AACjE,MAAI,UAAU,KAAM,QAAO;AAC3B,MAAI,UAAU,MAAO,QAAO;AAC5B,SAAO,KAAK,SAAS,UAAa,CAAC,MAAM,OAAO,SAAS,KAAK,IAAI;AACpE;AAWO,SAAS,aAAa,MAAiB,OAA2C;AACvF,MAAI,CAAC,KAAK,UAAU,UAAU,KAAM,QAAO;AAG3C,QAAM,QAAQ,KAAK,MAAM,SAAS,IAAI,KAAK,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,QAAQ,KAAK,OAAO,CAAC;AAC5F,QAAM,QAAQ,UAAU,SAAY,SAAY,MAAM,KAAK,CAAC,SAAS,QAAQ,MAAM,KAAK,CAAC;AACzF,MAAI,CAAC,MAAO,QAAO,EAAE,GAAG,UAAU,OAAO,KAAK,MAAM;AAEpD,MAAI,UAAU,MAAM,CAAC,EAAG,QAAO;AAC/B,SAAO,EAAE,QAAQ,MAAM,QAAQ,MAAM,QAAQ,MAAM,MAAM,MAAM,OAAO,KAAK,MAAM;AACnF;AAWO,SAAS,aAAa,QAAqB,MAAiB;AACjE,SAAO,aAAa,WAAW,gBAAgB,GAAG,KAAK;AACzD;AAQO,SAAS,gBAAgB,QAAiC,KAA2B;AAC1F,QAAM,OAAO,aAAa,WAAW,gBAAgB,GAAG,MAAM;AAC9D,SAAO,KAAK,SAAS,KAAK,SAAS;AACrC;","names":[]}

package/dist/{data-table-labels-kpAAVi6g.d.ts → data-table-labels-BJ5JE_X2.d.ts}

@@ -387,6 +387,23 @@ interface DataTableProps<T> {
     rowHref?: (row: T) => string | undefined;
     expandedRow?: (row: T) => ReactNode | null;
     isExpanded?: (row: T) => boolean;
+    /**
+     * Extra classes for a row — the `<tr>` on desktop, the card on mobile. Merged last,
+     * so a `hover:` fill here replaces the row's own `hover:bg-[var(--bg-hover)]`.
+     *
+     * **A row you paint has to pick its own hover** (0.33, docs/colour-roles-harmonization.md
+     * §12.2): the kit cannot see your rest colour, and `--bg-hover` is mixed against the
+     * card. The rule: a hover differs from its rest by 1.08:1 or more, and every text role
+     * on it keeps 4.5:1.
+     * - A row that rests on the well (`bg-surface-2`) hovers to the CARD,
+     *   `hover:bg-surface`: in light the well is the page, and `--bg-hover` sits 1.04:1
+     *   from it.
+     * - A row whose well MARKS A STATE (selected) keeps its fill and draws a 1 px inside
+     *   line instead, since the card would read as "not selected":
+     *   `bg-surface-2 hover:bg-surface-2 hover:outline hover:-outline-offset-1 hover:outline-strong`.
+     *   An outline, not a shadow: a shadow on a `<tr>` is not painted by every engine.
+     * - Not `--bg-active` for a selected row: its muted and money text fall to 3.8–4.7:1.
+     */
     rowClassName?: (row: T) => string | undefined;
     /**
      * Extra DOM attributes for a row's container — the `<tr>` on desktop, the

package/dist/data-table.d.ts

@@ -1,7 +1,18 @@
-export { C as ColumnFilter, D as DEFAULT_DATA_TABLE_LABELS, a as DEFAULT_DATA_TABLE_SORT_LABELS, b as DataTable, c as DataTableChrome, d as DataTableColumn, e as DataTableDensity, f as DataTableLabels, g as DataTableProps, h as DataTableRowAction, i as DataTableSortLabels, F as FilterState, j as FilterValue, M as MobileSwipeActions, S as ServerPagination, T as TableUrlState, k as TableUrlStateProps, l as TableUrlSync, U as UseTableUrlStateOptions, m as UseTableUrlStateReturn, n as dateFilter, o as decodeFilterValue, p as decodeFilterValueOfType, q as defaultFilterState, r as encodeFilterValue, s as filterHref, t as isFilterActive, u as missingDataTableLabels, v as numberFilter, w as readTableUrlState, x as resolveDataTableLabels, y as resolveFilter, z as rowMatches, A as selectFilter, B as textFilter, E as useTableUrlState } from './data-table-labels-kpAAVi6g.js';
+export { C as ColumnFilter, D as DEFAULT_DATA_TABLE_LABELS, a as DEFAULT_DATA_TABLE_SORT_LABELS, b as DataTable, c as DataTableChrome, d as DataTableColumn, e as DataTableDensity, f as DataTableLabels, g as DataTableProps, h as DataTableRowAction, i as DataTableSortLabels, F as FilterState, j as FilterValue, M as MobileSwipeActions, S as ServerPagination, T as TableUrlState, k as TableUrlStateProps, l as TableUrlSync, U as UseTableUrlStateOptions, m as UseTableUrlStateReturn, n as dateFilter, o as decodeFilterValue, p as decodeFilterValueOfType, q as defaultFilterState, r as encodeFilterValue, s as filterHref, t as isFilterActive, u as missingDataTableLabels, v as numberFilter, w as readTableUrlState, x as resolveDataTableLabels, y as resolveFilter, z as rowMatches, A as selectFilter, B as textFilter, E as useTableUrlState } from './data-table-labels-BJ5JE_X2.js';
 export { SortCycle, SortDir, SortState, SortStepOptions, decodeSorts, encodeSorts, nextSorts, normalizeSorts } from './components/data-table-sort.js';
 export { PAGE_SIZE_OPTIONS, Pagination } from './components/data-table-pagination.js';
 export { FilterPopover } from './components/data-table-filter-popover.js';
 export { BooleanColumnOptions, BooleanMark, BooleanMarkProps, booleanColumn } from './components/data-table-cells.js';
 import 'react';
 import './components/swipeable-row.js';
+import './components/status-dot.js';
+import './components/progress-bar.js';
+import './components/signed-amount.js';
+import './components/stat-tile.js';
+import './components/chip.js';
+import 'lucide-react';
+import './components/field-parts.js';
+import './components/tooltip.js';
+import './hooks/use-anchored-rect.js';
+import './lib/clipping.js';
+import './components/write-lock.js';