@jini-ai/admin 0.1.0

package/dist/core/transport/types.js

@@ -0,0 +1,43 @@
+/**
+ * @file The transport seam — the single primitive every admin route group is built on.
+ *
+ * ## Why this exists
+ *
+ * The reference implementation's `lib/api.ts` is 1,548 lines and 134 methods in one flat object literal,
+ * every one of them closing over a module-private `request()` and a module-private
+ * `BASE = "/api/admin/v1"`. That shape has two costs: the whole object is one unit (you cannot
+ * take the 67 generic methods without the 67 CMS-domain ones), and there is no way for a host to
+ * add a route group without editing the file.
+ *
+ * Inverting it — `request` becomes an injected `AdminTransport`, and each route group becomes a
+ * factory over it — makes both work:
+ *
+ * ```ts
+ * const transport = createHttpTransport({ baseUrl: '/api/admin/v1' });
+ *
+ * const client = createAdminClient(transport, {
+ *   identity: createIdentityRoutes,          // shipped by @jini-ai/admin
+ *   media:    createMediaRoutes,             // shipped by @jini-ai/admin
+ *   posts:    createHostPostRoutes,          // the host's own, same signature
+ *   widgets:  createHostWidgetRoutes,        // the host's own
+ * });
+ *
+ * await client.identity.listUsers();   // Jini's
+ * await client.posts.list();           // the host's
+ * ```
+ *
+ * Both halves share one auth policy, one error class, one place to add retries or tracing. A host
+ * adding a route is a factory plus one line in the map — it never edits a Jini file, and it never
+ * grows a second `fetch` wrapper with its own subtly different error handling, which is exactly
+ * how `api.ts` reached 1,548 lines.
+ *
+ * ## Why `AdminTransport` is an interface and not just a function
+ *
+ * A bare `request<T>(path, init)` function would have been enough for HTTP. It is an interface so
+ * a host can supply a non-HTTP implementation without any route group knowing: a fleet orchestrator
+ * drives many site instances in-process and can hand over a direct-dispatch transport that never opens a
+ * socket, and tests can supply a fake that returns fixtures. Both are the same seam, which is the
+ * point.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/transport/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/transport/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG"}

package/dist/react/components/ConfirmButton/ConfirmButton.d.ts

@@ -0,0 +1,40 @@
+import { useConfirmButton } from './ConfirmButton.hooks.js';
+export interface ConfirmButtonProps {
+    /** Resting-state label, e.g. "Delete". */
+    label: string;
+    /** Label shown after the first (arming) click, while awaiting the confirming second click. */
+    confirmLabel: string;
+    /** Fired on the second (confirming) click. The caller owns in-flight/error state after that —
+     *  this component only owns the armed/disarmed distinction. */
+    onConfirm: () => void;
+    /** Applies `.btn-danger`. Reserve for genuinely irreversible actions; a reversible-but-access-
+     *  affecting action (e.g. Disable) should leave this `false` — see {@link ConfirmTone}'s
+     *  warning-vs-danger split, which this boolean predates and cannot express. */
+    destructive?: boolean;
+    /** External in-flight flag (e.g. `rowSavingId === row.id`). Shows `pendingLabel` and disables the
+     *  control. Not itself cancelable — a click already fired `onConfirm` by the time this is true. */
+    pending?: boolean;
+    pendingLabel?: string;
+    /** Disables the control outright — e.g. a built-in row the server would reject anyway. */
+    disabled?: boolean;
+    className?: string;
+    /** Overrides the computed accessible name. Use when several identical-looking controls share a
+     *  page (one "Delete" per table row) and the row's own text doesn't disambiguate them for a
+     *  screen-reader user navigating control-by-control rather than row-by-row. */
+    ariaLabel?: string;
+    /** Injectable seam for the armed/disarmed state hook. Defaults to the real
+     *  {@link useConfirmButton}; a test can pass a fake here to exercise `ConfirmButton`'s rendering
+     *  without driving the real Escape/outside-click/blur dismissal logic. */
+    useConfirmButton?: typeof useConfirmButton;
+}
+/**
+ * Two-click in-place confirm button. First click arms it: swaps the visible label to `confirmLabel`
+ * and announces the armed state through a `.visually-hidden` live region (a separate region rather
+ * than relying on the button's own label swap, since AT support for announcing a text change inside
+ * a live-region-less `<button>`'s accessible name is inconsistent across screen readers). Second
+ * click fires `onConfirm` and disarms immediately. Arm/disarm state and its Escape/outside-click/
+ * blur dismissal live in {@link useConfirmButton} (injectable via the `useConfirmButton` prop,
+ * defaulted to the real implementation, so a test can supply a fake without mocking modules).
+ */
+export declare function ConfirmButton({ useConfirmButton: useConfirmButtonState, ...props }: ConfirmButtonProps): import("react").JSX.Element;
+//# sourceMappingURL=ConfirmButton.d.ts.map

package/dist/react/components/ConfirmButton/ConfirmButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmButton.d.ts","sourceRoot":"","sources":["../../../../src/react/components/ConfirmButton/ConfirmButton.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAsB5D,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,8FAA8F;IAC9F,YAAY,EAAE,MAAM,CAAC;IACrB;mEAC+D;IAC/D,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;mFAE+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;uGACmG;IACnG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;mFAE+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;8EAE0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,EAAE,gBAAgB,EAAE,qBAAwC,EAAE,GAAG,KAAK,EAAE,EAAE,kBAAkB,+BA0CzH"}

package/dist/react/components/ConfirmButton/ConfirmButton.hooks.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file `ConfirmButton`'s armed/disarmed state, split out of the component so it can be swapped for
+ * a fake via the `useConfirmButton` prop on `ConfirmButtonProps` — see that prop's doc comment in
+ * `ConfirmButton.tsx`.
+ */
+/**
+ * Owns `ConfirmButton`'s armed/disarmed state: arms on the first click, disarms on Escape, an
+ * outside mousedown, or a blur — all without firing `onConfirm`, so a control armed and then
+ * abandoned (a slow screen-reader read-through, a misclick landing elsewhere) cannot later be fired
+ * by an unrelated click landing on the same screen position. The second click while armed fires
+ * `onConfirm` and disarms immediately.
+ *
+ * @complexity O(1) per render/interaction. The two document-level listeners are attached only while
+ * armed, not for the component's whole mounted lifetime.
+ */
+export declare function useConfirmButton(pending: boolean | undefined, disabled: boolean | undefined, onConfirm: () => void): {
+    confirming: boolean;
+    buttonRef: import("react").RefObject<HTMLButtonElement | null>;
+    handleClick: () => void;
+    handleBlur: () => void;
+};
+//# sourceMappingURL=ConfirmButton.hooks.d.ts.map

package/dist/react/components/ConfirmButton/ConfirmButton.hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmButton.hooks.d.ts","sourceRoot":"","sources":["../../../../src/react/components/ConfirmButton/ConfirmButton.hooks.tsx"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,IAAI;;;;;EAyClH"}

package/dist/react/components/ConfirmButton/ConfirmButton.hooks.js

@@ -0,0 +1,59 @@
+import { useEffect, useRef, useState } from 'react';
+/**
+ * @file `ConfirmButton`'s armed/disarmed state, split out of the component so it can be swapped for
+ * a fake via the `useConfirmButton` prop on `ConfirmButtonProps` — see that prop's doc comment in
+ * `ConfirmButton.tsx`.
+ */
+/**
+ * Owns `ConfirmButton`'s armed/disarmed state: arms on the first click, disarms on Escape, an
+ * outside mousedown, or a blur — all without firing `onConfirm`, so a control armed and then
+ * abandoned (a slow screen-reader read-through, a misclick landing elsewhere) cannot later be fired
+ * by an unrelated click landing on the same screen position. The second click while armed fires
+ * `onConfirm` and disarms immediately.
+ *
+ * @complexity O(1) per render/interaction. The two document-level listeners are attached only while
+ * armed, not for the component's whole mounted lifetime.
+ */
+export function useConfirmButton(pending, disabled, onConfirm) {
+    const [confirming, setConfirming] = useState(false);
+    const buttonRef = useRef(null);
+    // Listeners are scoped to the armed window only — an idle (disarmed) ConfirmButton costs nothing
+    // beyond the button element itself, so mounting many of them (one per table row) does not add a
+    // standing per-row document listener.
+    useEffect(() => {
+        if (!confirming)
+            return;
+        function disarm() {
+            setConfirming(false);
+        }
+        function onDocMouseDown(e) {
+            if (!buttonRef.current?.contains(e.target))
+                disarm();
+        }
+        function onKeyDown(e) {
+            if (e.key === 'Escape')
+                disarm();
+        }
+        document.addEventListener('mousedown', onDocMouseDown);
+        document.addEventListener('keydown', onKeyDown);
+        return () => {
+            document.removeEventListener('mousedown', onDocMouseDown);
+            document.removeEventListener('keydown', onKeyDown);
+        };
+    }, [confirming]);
+    function handleClick() {
+        if (pending || disabled)
+            return;
+        if (!confirming) {
+            setConfirming(true);
+            return;
+        }
+        setConfirming(false);
+        onConfirm();
+    }
+    function handleBlur() {
+        setConfirming(false);
+    }
+    return { confirming, buttonRef, handleClick, handleBlur };
+}
+//# sourceMappingURL=ConfirmButton.hooks.js.map

package/dist/react/components/ConfirmButton/ConfirmButton.hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmButton.hooks.js","sourceRoot":"","sources":["../../../../src/react/components/ConfirmButton/ConfirmButton.hooks.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEpD;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAA4B,EAAE,QAA6B,EAAE,SAAqB;IACjH,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpD,MAAM,SAAS,GAAG,MAAM,CAAoB,IAAI,CAAC,CAAC;IAElD,iGAAiG;IACjG,gGAAgG;IAChG,sCAAsC;IACtC,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,UAAU;YAAE,OAAO;QACxB,SAAS,MAAM;YACb,aAAa,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QACD,SAAS,cAAc,CAAC,CAAwB;YAC9C,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAc,CAAC;gBAAE,MAAM,EAAE,CAAC;QAC/D,CAAC;QACD,SAAS,SAAS,CAAC,CAA2B;YAC5C,IAAI,CAAC,CAAC,GAAG,KAAK,QAAQ;gBAAE,MAAM,EAAE,CAAC;QACnC,CAAC;QACD,QAAQ,CAAC,gBAAgB,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QACvD,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAChD,OAAO,GAAG,EAAE;YACV,QAAQ,CAAC,mBAAmB,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;YAC1D,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACrD,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,SAAS,WAAW;QAClB,IAAI,OAAO,IAAI,QAAQ;YAAE,OAAO;QAChC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,aAAa,CAAC,IAAI,CAAC,CAAC;YACpB,OAAO;QACT,CAAC;QACD,aAAa,CAAC,KAAK,CAAC,CAAC;QACrB,SAAS,EAAE,CAAC;IACd,CAAC;IAED,SAAS,UAAU;QACjB,aAAa,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC;AAC5D,CAAC"}

package/dist/react/components/ConfirmButton/ConfirmButton.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useConfirmButton } from './ConfirmButton.hooks.js';
+/**
+ * @file Shared two-click, in-place confirmation control for destructive or access-affecting
+ * actions.
+ *
+ * Exists because confirmation coverage is otherwise a coin flip: some screens guard a delete, some
+ * ship a bare single-click Disable, and the ones that do guard each reinvent the interaction. This
+ * is the one shape every screen can import instead of rebuilding.
+ *
+ * Chosen over a `window.confirm` wrapper: `window.confirm` blocks the whole tab and cannot carry
+ * destructive-vs-warning styling or a screen-reader-specific announcement. Chosen over a shared
+ * modal for the common case because the in-place shape needs no new markup at all — it renders as
+ * an ordinary `<button>`, optionally with `.btn-danger`.
+ *
+ * Not a replacement for {@link ConfirmDialog}: an operation with real context to disclose ("this
+ * restores a snapshot from 3 days ago and drops 41 entries") needs a modal that can show it. This
+ * is for the common case — a single row action that would otherwise be bare or a `window.confirm`.
+ */
+const DEFAULT_PENDING_LABEL = '…';
+/**
+ * Two-click in-place confirm button. First click arms it: swaps the visible label to `confirmLabel`
+ * and announces the armed state through a `.visually-hidden` live region (a separate region rather
+ * than relying on the button's own label swap, since AT support for announcing a text change inside
+ * a live-region-less `<button>`'s accessible name is inconsistent across screen readers). Second
+ * click fires `onConfirm` and disarms immediately. Arm/disarm state and its Escape/outside-click/
+ * blur dismissal live in {@link useConfirmButton} (injectable via the `useConfirmButton` prop,
+ * defaulted to the real implementation, so a test can supply a fake without mocking modules).
+ */
+export function ConfirmButton({ useConfirmButton: useConfirmButtonState = useConfirmButton, ...props }) {
+    const { confirming, buttonRef, handleClick, handleBlur } = useConfirmButtonState(props.pending, props.disabled, props.onConfirm);
+    const label = props.pending
+        ? (props.pendingLabel ?? DEFAULT_PENDING_LABEL)
+        : confirming
+            ? props.confirmLabel
+            : props.label;
+    const className = [props.className, props.destructive ? 'btn-danger' : null].filter(Boolean).join(' ') || undefined;
+    return (_jsxs(_Fragment, { children: [_jsx("button", { ref: buttonRef, type: "button", className: className, "data-armed": confirming ? 'true' : undefined, disabled: props.disabled || props.pending, onClick: handleClick, onBlur: handleBlur, "aria-label": props.ariaLabel, children: label }), _jsx("span", { className: "visually-hidden", role: "status", "aria-live": "polite", children: confirming ? `Press "${props.confirmLabel}" to confirm, or press Escape to cancel.` : '' })] }));
+}
+//# sourceMappingURL=ConfirmButton.js.map

package/dist/react/components/ConfirmButton/ConfirmButton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmButton.js","sourceRoot":"","sources":["../../../../src/react/components/ConfirmButton/ConfirmButton.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,qBAAqB,GAAG,GAAG,CAAC;AA+BlC;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,EAAE,gBAAgB,EAAE,qBAAqB,GAAG,gBAAgB,EAAE,GAAG,KAAK,EAAsB;IACxH,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,qBAAqB,CAC9E,KAAK,CAAC,OAAO,EACb,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,SAAS,CAChB,CAAC;IAEF,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO;QACzB,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,IAAI,qBAAqB,CAAC;QAC/C,CAAC,CAAC,UAAU;YACV,CAAC,CAAC,KAAK,CAAC,YAAY;YACpB,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;IAClB,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC;IAEpH,OAAO,CACL,8BAOE,iBACE,GAAG,EAAE,SAAS,EACd,IAAI,EAAC,QAAQ,EACb,SAAS,EAAE,SAAS,gBACR,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,EAC3C,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,OAAO,EACzC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,UAAU,gBACN,KAAK,CAAC,SAAS,YAE1B,KAAK,GACC,EAIT,eAAM,SAAS,EAAC,iBAAiB,EAAC,IAAI,EAAC,QAAQ,eAAW,QAAQ,YAC/D,UAAU,CAAC,CAAC,CAAC,UAAU,KAAK,CAAC,YAAY,0CAA0C,CAAC,CAAC,CAAC,EAAE,GACpF,IACN,CACJ,CAAC;AACJ,CAAC"}

package/dist/react/components/ConfirmButton.d.ts

@@ -0,0 +1,39 @@
+export interface ConfirmButtonProps {
+    /** Resting-state label, e.g. "Delete". */
+    label: string;
+    /** Label shown after the first (arming) click, while awaiting the confirming second click. */
+    confirmLabel: string;
+    /** Fired on the second (confirming) click. The caller owns in-flight/error state after that —
+     *  this component only owns the armed/disarmed distinction. */
+    onConfirm: () => void;
+    /** Applies `.btn-danger`. Reserve for genuinely irreversible actions; a reversible-but-access-
+     *  affecting action (e.g. Disable) should leave this `false` — see {@link ConfirmTone}'s
+     *  warning-vs-danger split, which this boolean predates and cannot express. */
+    destructive?: boolean;
+    /** External in-flight flag (e.g. `rowSavingId === row.id`). Shows `pendingLabel` and disables the
+     *  control. Not itself cancelable — a click already fired `onConfirm` by the time this is true. */
+    pending?: boolean;
+    pendingLabel?: string;
+    /** Disables the control outright — e.g. a built-in row the server would reject anyway. */
+    disabled?: boolean;
+    className?: string;
+    /** Overrides the computed accessible name. Use when several identical-looking controls share a
+     *  page (one "Delete" per table row) and the row's own text doesn't disambiguate them for a
+     *  screen-reader user navigating control-by-control rather than row-by-row. */
+    ariaLabel?: string;
+}
+/**
+ * Two-click in-place confirm button. First click arms it: swaps the visible label to `confirmLabel`
+ * and announces the armed state through a `.visually-hidden` live region (a separate region rather
+ * than relying on the button's own label swap, since AT support for announcing a text change inside
+ * a live-region-less `<button>`'s accessible name is inconsistent across screen readers). Second
+ * click fires `onConfirm` and disarms immediately. Losing focus, an outside click, or Escape
+ * disarms without firing, so a control armed and then abandoned (a slow screen-reader read-through,
+ * a misclick landing elsewhere) cannot later be fired by an unrelated click landing on the same
+ * screen position.
+ *
+ * @complexity O(1) per render/interaction. The two document-level listeners are attached only while
+ * armed, not for the component's whole mounted lifetime.
+ */
+export declare function ConfirmButton(props: ConfirmButtonProps): import("react").JSX.Element;
+//# sourceMappingURL=ConfirmButton.d.ts.map

package/dist/react/components/ConfirmButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmButton.d.ts","sourceRoot":"","sources":["../../../src/react/components/ConfirmButton.tsx"],"names":[],"mappings":"AAsBA,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,8FAA8F;IAC9F,YAAY,EAAE,MAAM,CAAC;IACrB;mEAC+D;IAC/D,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB;;mFAE+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;uGACmG;IACnG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;mFAE+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,+BAuEtD"}

package/dist/react/components/ConfirmButton.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+/**
+ * @file Shared two-click, in-place confirmation control for destructive or access-affecting
+ * actions.
+ *
+ * Exists because confirmation coverage is otherwise a coin flip: some screens guard a delete, some
+ * ship a bare single-click Disable, and the ones that do guard each reinvent the interaction. This
+ * is the one shape every screen can import instead of rebuilding.
+ *
+ * Chosen over a `window.confirm` wrapper: `window.confirm` blocks the whole tab and cannot carry
+ * destructive-vs-warning styling or a screen-reader-specific announcement. Chosen over a shared
+ * modal for the common case because the in-place shape needs no new markup at all — it renders as
+ * an ordinary `<button>`, optionally with `.btn-danger`.
+ *
+ * Not a replacement for {@link ConfirmDialog}: an operation with real context to disclose ("this
+ * restores a snapshot from 3 days ago and drops 41 entries") needs a modal that can show it. This
+ * is for the common case — a single row action that would otherwise be bare or a `window.confirm`.
+ */
+const DEFAULT_PENDING_LABEL = '…';
+/**
+ * Two-click in-place confirm button. First click arms it: swaps the visible label to `confirmLabel`
+ * and announces the armed state through a `.visually-hidden` live region (a separate region rather
+ * than relying on the button's own label swap, since AT support for announcing a text change inside
+ * a live-region-less `<button>`'s accessible name is inconsistent across screen readers). Second
+ * click fires `onConfirm` and disarms immediately. Losing focus, an outside click, or Escape
+ * disarms without firing, so a control armed and then abandoned (a slow screen-reader read-through,
+ * a misclick landing elsewhere) cannot later be fired by an unrelated click landing on the same
+ * screen position.
+ *
+ * @complexity O(1) per render/interaction. The two document-level listeners are attached only while
+ * armed, not for the component's whole mounted lifetime.
+ */
+export function ConfirmButton(props) {
+    const [confirming, setConfirming] = useState(false);
+    const buttonRef = useRef(null);
+    // Listeners are scoped to the armed window only — an idle (disarmed) ConfirmButton costs nothing
+    // beyond the button element itself, so mounting many of them (one per table row) does not add a
+    // standing per-row document listener.
+    useEffect(() => {
+        if (!confirming)
+            return;
+        function disarm() {
+            setConfirming(false);
+        }
+        function onDocMouseDown(e) {
+            if (!buttonRef.current?.contains(e.target))
+                disarm();
+        }
+        function onKeyDown(e) {
+            if (e.key === 'Escape')
+                disarm();
+        }
+        document.addEventListener('mousedown', onDocMouseDown);
+        document.addEventListener('keydown', onKeyDown);
+        return () => {
+            document.removeEventListener('mousedown', onDocMouseDown);
+            document.removeEventListener('keydown', onKeyDown);
+        };
+    }, [confirming]);
+    function handleClick() {
+        if (props.pending || props.disabled)
+            return;
+        if (!confirming) {
+            setConfirming(true);
+            return;
+        }
+        setConfirming(false);
+        props.onConfirm();
+    }
+    const label = props.pending
+        ? (props.pendingLabel ?? DEFAULT_PENDING_LABEL)
+        : confirming
+            ? props.confirmLabel
+            : props.label;
+    const className = [props.className, props.destructive ? 'btn-danger' : null].filter(Boolean).join(' ') || undefined;
+    return (_jsxs(_Fragment, { children: [_jsx("button", { ref: buttonRef, type: "button", className: className, "data-armed": confirming ? 'true' : undefined, disabled: props.disabled || props.pending, onClick: handleClick, onBlur: () => setConfirming(false), "aria-label": props.ariaLabel, children: label }), _jsx("span", { className: "visually-hidden", role: "status", "aria-live": "polite", children: confirming ? `Press "${props.confirmLabel}" to confirm, or press Escape to cancel.` : '' })] }));
+}
+//# sourceMappingURL=ConfirmButton.js.map

package/dist/react/components/ConfirmButton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmButton.js","sourceRoot":"","sources":["../../../src/react/components/ConfirmButton.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,qBAAqB,GAAG,GAAG,CAAC;AA2BlC;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,KAAyB;IACrD,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpD,MAAM,SAAS,GAAG,MAAM,CAAoB,IAAI,CAAC,CAAC;IAElD,iGAAiG;IACjG,gGAAgG;IAChG,sCAAsC;IACtC,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,UAAU;YAAE,OAAO;QACxB,SAAS,MAAM;YACb,aAAa,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QACD,SAAS,cAAc,CAAC,CAAwB;YAC9C,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAc,CAAC;gBAAE,MAAM,EAAE,CAAC;QAC/D,CAAC;QACD,SAAS,SAAS,CAAC,CAA2B;YAC5C,IAAI,CAAC,CAAC,GAAG,KAAK,QAAQ;gBAAE,MAAM,EAAE,CAAC;QACnC,CAAC;QACD,QAAQ,CAAC,gBAAgB,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QACvD,QAAQ,CAAC,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAChD,OAAO,GAAG,EAAE;YACV,QAAQ,CAAC,mBAAmB,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;YAC1D,QAAQ,CAAC,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACrD,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,SAAS,WAAW;QAClB,IAAI,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,QAAQ;YAAE,OAAO;QAC5C,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,aAAa,CAAC,IAAI,CAAC,CAAC;YACpB,OAAO;QACT,CAAC;QACD,aAAa,CAAC,KAAK,CAAC,CAAC;QACrB,KAAK,CAAC,SAAS,EAAE,CAAC;IACpB,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO;QACzB,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,IAAI,qBAAqB,CAAC;QAC/C,CAAC,CAAC,UAAU;YACV,CAAC,CAAC,KAAK,CAAC,YAAY;YACpB,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;IAClB,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC;IAEpH,OAAO,CACL,8BAOE,iBACE,GAAG,EAAE,SAAS,EACd,IAAI,EAAC,QAAQ,EACb,SAAS,EAAE,SAAS,gBACR,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,EAC3C,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,OAAO,EACzC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,gBACtB,KAAK,CAAC,SAAS,YAE1B,KAAK,GACC,EAIT,eAAM,SAAS,EAAC,iBAAiB,EAAC,IAAI,EAAC,QAAQ,eAAW,QAAQ,YAC/D,UAAU,CAAC,CAAC,CAAC,UAAU,KAAK,CAAC,YAAY,0CAA0C,CAAC,CAAC,CAAC,EAAE,GACpF,IACN,CACJ,CAAC;AACJ,CAAC"}

package/dist/react/components/ConfirmDialog/ConfirmDialog.d.ts

@@ -0,0 +1,90 @@
+import { type ReactNode } from 'react';
+import { type ConfirmTone } from '../../types.js';
+import { type UseConfirmDialog } from './ConfirmDialog.hooks.js';
+/**
+ * @file Shared modal confirmation primitive — the replacement for `window.confirm`, which blocks
+ * the whole tab, cannot carry destructive-vs-neutral styling, and reads as a browser artifact
+ * rather than part of the product.
+ *
+ * Built on the native `<dialog>` element (`showModal()`/`close()`) rather than a plain-`<div>`
+ * overlay + backdrop idiom: that shape hand-rolls focus trapping, Escape handling, and a backdrop
+ * element, all of which the browser's own top layer gives a real `<dialog>` for free, including
+ * correct stacking above everything else on the page without a chosen `z-index`. The `showModal`/
+ * `close` calls themselves, and the jsdom fallback they need, live in `ConfirmDialog.hooks.tsx` —
+ * see that file's doc comment.
+ *
+ * Unstyled, like everything in this layer: the `.confirm-dialog` / `.btn-secondary` /
+ * `.btn-danger` / `.btn-warning` class names are emitted for the host stylesheet to define.
+ *
+ * ## Agent handles
+ *
+ * Given `agentHandle="delete-role"` this publishes:
+ *
+ * | element | handle | role |
+ * |---|---|---|
+ * | the confirm action | `delete-role-confirm` | `button` |
+ * | the cancel/dismiss action | `delete-role-cancel` | `button` |
+ *
+ * Both segments are literals this component chooses itself, never host data — unlike `RowMenu`'s
+ * per-item keys (arbitrary host strings that can collide after slugifying), `confirm`/`cancel`
+ * need no sanitizing. `agentHandle` itself is NOT sanitized either: it is the caller's own explicit
+ * choice of name, and a bad one should fail loudly at first render rather than silently answer to a
+ * handle the caller never wrote. Omit `agentHandle` and no `data-agent-*` markup is emitted at all.
+ *
+ * Both handles are present in the DOM as soon as `agentHandle` is supplied, regardless of `open` —
+ * this component stays mounted and toggles the native `<dialog>`'s open state rather than being
+ * conditionally rendered by its caller (see `useConfirmDialog`'s doc comment), so there is no
+ * "closed" render that omits them, the same reasoning `RowMenu`'s always-visible trigger handle
+ * documents for itself.
+ *
+ * This component renders no typed-confirmation input today (no "type DELETE to confirm" field) —
+ * if one is added later it needs its own handle under this same scheme (e.g. `<base>-confirm-input`,
+ * role `field`).
+ *
+ * Labels state both the action and its consequence tier, derived from this component's own
+ * three-tier `ConfirmTone` vocabulary rather than reparsed from `title`/`body`: `body` is arbitrary
+ * `ReactNode` (a caller can pass JSX), not guaranteed to be a string at all, so it cannot be safely
+ * folded into agent-facing text — see {@link confirmDialogConsequencePhrase}.
+ */
+export interface ConfirmDialogProps {
+    open: boolean;
+    title: string;
+    body: ReactNode;
+    confirmLabel: string;
+    /** @default "Cancel" */
+    cancelLabel?: string;
+    /** Applies `.btn-warning`/`.btn-danger` to the confirm action. Defaults to `"default"` (no class,
+     *  the plain primary button). Wins over `destructive` below when both are passed. */
+    tone?: ConfirmTone;
+    /** @deprecated Use `tone: "danger"` instead — this only ever expressed the danger tier, and the
+     *  vocabulary has a second one (`"warning"`) this boolean cannot reach. Kept working (mapped to
+     *  `tone: "danger"` when `tone` is not set) for existing callers rather than a breaking rename. */
+    destructive?: boolean;
+    /** External in-flight flag. Disables both actions and blocks Escape/backdrop dismissal so a
+     *  request already underway cannot be raced by a second dismiss. */
+    pending?: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+    /** Injectable seam for the dialog's open/close and focus-management hook. Defaults to the real
+     *  {@link useConfirmDialog}; a test can pass a fake here to exercise `ConfirmDialog`'s rendering
+     *  without invoking the native `<dialog>` methods or DOM focus calls at all.
+     *
+     *  Typed against the explicit `UseConfirmDialog` contract rather than `typeof useConfirmDialog`:
+     *  see `ConfirmDialogController`'s doc comment for why binding a public prop to a concrete
+     *  implementation's inferred return object is a coupling rather than a convenience. */
+    useDialog?: UseConfirmDialog;
+    /** This dialog's own agent handle — see this file's "Agent handles" doc comment for the full
+     *  scheme. Omit and no `data-agent-*` markup is emitted at all. */
+    agentHandle?: string;
+}
+/**
+ * Controlled modal confirm — renders the `<dialog>` markup and delegates its open/close and focus
+ * lifecycle to {@link useConfirmDialog} (injectable via the `useDialog` prop, defaulted to the real
+ * implementation, so a test can supply a fake without mocking modules).
+ *
+ * Both actions are plain `type="button"` (no `<form method="dialog">`, no `type="submit"`), so there
+ * is no browser-assigned "default button" for Enter to reach for at all; confirm can only ever fire
+ * from an explicit click or explicit Tab-then-Enter onto it.
+ */
+export declare function ConfirmDialog({ useDialog, agentHandle: baseHandle, ...props }: ConfirmDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=ConfirmDialog.d.ts.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmDialog.d.ts","sourceRoot":"","sources":["../../../../src/react/components/ConfirmDialog/ConfirmDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAA8B,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,wBAAwB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;yFACqF;IACrF,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;uGAEmG;IACnG,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;wEACoE;IACpE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB;;;;;;2FAMuF;IACvF,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B;uEACmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA2ED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,EAAE,SAA4B,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,KAAK,EAAE,EAAE,kBAAkB,+BAiDpH"}

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.d.ts

@@ -0,0 +1,49 @@
+import { type MouseEvent, type RefObject, type SyntheticEvent } from 'react';
+/**
+ * @file `ConfirmDialog`'s open/close and focus-management state, split out of the component so it
+ * can be swapped for a fake via the `useDialog` prop on `ConfirmDialogProps` — see that prop's doc
+ * comment in `ConfirmDialog.tsx`.
+ *
+ * `dialog.showModal()`/`dialog.close()` are guarded by a `typeof` check rather than called
+ * unconditionally: jsdom (this package's React test environment, verified directly rather than
+ * assumed) does not implement either method at all — calling them throws `TypeError`. The fallback
+ * branch below toggles the plain `open` attribute instead, which no browser shipping a real
+ * `<dialog>` ever takes (the `showModal`/`close` branch always wins there), so this only changes
+ * behavior under jsdom, where it keeps the dialog mountable and its content queryable.
+ */
+/**
+ * What `ConfirmDialog` needs back from whatever drives its dialog lifecycle: the two refs it
+ * attaches and the two handlers it wires, plus the id its `aria-labelledby` points at.
+ *
+ * Declared as its own interface rather than left to be inferred from {@link useConfirmDialog}'s
+ * return object. That inference is what made the injectable `useDialog` prop couple to the concrete
+ * implementation: `typeof useConfirmDialog` meant every internal detail of the default hook's shape
+ * became part of the component's PUBLIC contract, so adding a field for the default's own
+ * convenience would silently break every substitute a consumer had already written. Naming the
+ * contract inverts that — the hook now has to satisfy the component, not the other way round.
+ */
+export interface ConfirmDialogController {
+    /** Id for the dialog's `<h2>`, unique per mounted instance — see {@link useConfirmDialog}. */
+    titleId: string;
+    dialogRef: RefObject<HTMLDialogElement | null>;
+    cancelRef: RefObject<HTMLButtonElement | null>;
+    handleNativeCancel: (event: SyntheticEvent<HTMLDialogElement>) => void;
+    handleBackdropClick: (event: MouseEvent<HTMLDialogElement>) => void;
+}
+/** The signature `ConfirmDialogProps.useDialog` accepts. Any hook matching this can drive the
+ *  component; it does not have to be {@link useConfirmDialog}, or even use React state at all. */
+export type UseConfirmDialog = (open: boolean, pending: boolean | undefined, onCancel: () => void) => ConfirmDialogController;
+/**
+ * Owns the `<dialog>` element's open/close lifecycle and focus management for `ConfirmDialog`.
+ *
+ * The caller keeps `ConfirmDialog` mounted and toggles `open` — it is never conditionally rendered
+ * by its parent — so the effect below has a stable `<dialog>` element to call `showModal()`/
+ * `close()` on and to restore focus through when it closes.
+ *
+ * Focus moves to the *cancel* action on open, not confirm — an operator whose first keystroke after
+ * a slow read-through is Enter should land on the safe action, not the destructive one.
+ *
+ * @complexity O(1) per open/close transition — one `showModal`/`close` call and one focus move.
+ */
+export declare function useConfirmDialog(open: boolean, pending: boolean | undefined, onCancel: () => void): ConfirmDialogController;
+//# sourceMappingURL=ConfirmDialog.hooks.d.ts.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmDialog.hooks.d.ts","sourceRoot":"","sources":["../../../../src/react/components/ConfirmDialog/ConfirmDialog.hooks.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AAEvG;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,uBAAuB;IACtC,8FAA8F;IAC9F,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC/C,SAAS,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC/C,kBAAkB,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;IACvE,mBAAmB,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;CACrE;AAED;kGACkG;AAClG,MAAM,MAAM,gBAAgB,GAAG,CAC7B,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,QAAQ,EAAE,MAAM,IAAI,KACjB,uBAAuB,CAAC;AAE7B;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,QAAQ,EAAE,MAAM,IAAI,GACnB,uBAAuB,CA4DzB"}

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.js

@@ -0,0 +1,81 @@
+import { useEffect, useId, useRef } from 'react';
+/**
+ * Owns the `<dialog>` element's open/close lifecycle and focus management for `ConfirmDialog`.
+ *
+ * The caller keeps `ConfirmDialog` mounted and toggles `open` — it is never conditionally rendered
+ * by its parent — so the effect below has a stable `<dialog>` element to call `showModal()`/
+ * `close()` on and to restore focus through when it closes.
+ *
+ * Focus moves to the *cancel* action on open, not confirm — an operator whose first keystroke after
+ * a slow read-through is Enter should land on the safe action, not the destructive one.
+ *
+ * @complexity O(1) per open/close transition — one `showModal`/`close` call and one focus move.
+ */
+export function useConfirmDialog(open, pending, onCancel) {
+    // `useId()`, not a string literal — a hardcoded id breaks the moment a screen mounts two
+    // `ConfirmDialog`s at once (a delete-role and a delete-policy confirm on one page, both
+    // stay-mounted/toggle-`open` per this hook's own doc comment above): two `<h2>`s share one
+    // id, and `aria-labelledby` resolves via `getElementById`, which always returns the FIRST match
+    // in document order regardless of which dialog is actually open — a screen reader announcing
+    // "Delete role?" while the operator is about to confirm "Delete policy?", on a destructive
+    // action. `useId()` gives every mounted instance its own id for free.
+    const titleId = useId();
+    const dialogRef = useRef(null);
+    const cancelRef = useRef(null);
+    // Captured at the moment `open` flips true, before focus moves into the dialog — the element that
+    // had focus then is, by construction, whatever triggered this dialog (a `RowMenu` item's
+    // "Delete", a plain trigger button, …). Restored on close rather than left wherever the browser's
+    // own modal-focus algorithm happened to land (its default without this is `<body>`, which drops a
+    // keyboard user back to the top of the page).
+    const triggerRef = useRef(null);
+    useEffect(() => {
+        const dialog = dialogRef.current;
+        if (!dialog)
+            return;
+        if (open) {
+            triggerRef.current = document.activeElement;
+            if (typeof dialog.showModal === 'function') {
+                if (!dialog.open)
+                    dialog.showModal();
+            }
+            else {
+                dialog.setAttribute('open', '');
+            }
+            cancelRef.current?.focus();
+        }
+        else {
+            if (typeof dialog.close === 'function') {
+                if (dialog.open)
+                    dialog.close();
+            }
+            else {
+                dialog.removeAttribute('open');
+            }
+            if (triggerRef.current instanceof HTMLElement)
+                triggerRef.current.focus();
+        }
+    }, [open]);
+    function handleNativeCancel(e) {
+        // Fires on Escape while a real `showModal()`-opened dialog has focus. Always prevented: the
+        // effect above is the single source of truth for open/closed (driven by `open`), so
+        // letting the browser close the element on its own would desync DOM state from React state.
+        // Escape still closes the dialog — it just does so by routing through `onCancel`, same as a
+        // Cancel-button click, so the caller's `open` state (and therefore this same effect) is what
+        // actually calls `dialog.close()`.
+        e.preventDefault();
+        if (pending)
+            return;
+        onCancel();
+    }
+    function handleBackdropClick(e) {
+        // A `<dialog>` element's own box is sized to its content, not the viewport — a click that lands
+        // on the `<dialog>` element itself (as opposed to one of its children) is therefore a click on
+        // the backdrop area outside that content box.
+        if (pending)
+            return;
+        if (e.target === dialogRef.current)
+            onCancel();
+    }
+    return { titleId, dialogRef, cancelRef, handleNativeCancel, handleBackdropClick };
+}
+//# sourceMappingURL=ConfirmDialog.hooks.js.map

package/dist/react/components/ConfirmDialog/ConfirmDialog.hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfirmDialog.hooks.js","sourceRoot":"","sources":["../../../../src/react/components/ConfirmDialog/ConfirmDialog.hooks.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAwD,MAAM,OAAO,CAAC;AA2CvG;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAa,EACb,OAA4B,EAC5B,QAAoB;IAEpB,yFAAyF;IACzF,wFAAwF;IACxF,2FAA2F;IAC3F,gGAAgG;IAChG,6FAA6F;IAC7F,2FAA2F;IAC3F,sEAAsE;IACtE,MAAM,OAAO,GAAG,KAAK,EAAE,CAAC;IACxB,MAAM,SAAS,GAAG,MAAM,CAAoB,IAAI,CAAC,CAAC;IAClD,MAAM,SAAS,GAAG,MAAM,CAAoB,IAAI,CAAC,CAAC;IAClD,kGAAkG;IAClG,yFAAyF;IACzF,kGAAkG;IAClG,kGAAkG;IAClG,8CAA8C;IAC9C,MAAM,UAAU,GAAG,MAAM,CAAiB,IAAI,CAAC,CAAC;IAEhD,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC;QACjC,IAAI,CAAC,MAAM;YAAE,OAAO;QACpB,IAAI,IAAI,EAAE,CAAC;YACT,UAAU,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC;YAC5C,IAAI,OAAO,MAAM,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;gBAC3C,IAAI,CAAC,MAAM,CAAC,IAAI;oBAAE,MAAM,CAAC,SAAS,EAAE,CAAC;YACvC,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;YAClC,CAAC;YACD,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;gBACvC,IAAI,MAAM,CAAC,IAAI;oBAAE,MAAM,CAAC,KAAK,EAAE,CAAC;YAClC,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YACjC,CAAC;YACD,IAAI,UAAU,CAAC,OAAO,YAAY,WAAW;gBAAE,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAC5E,CAAC;IACH,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAEX,SAAS,kBAAkB,CAAC,CAAoC;QAC9D,4FAA4F;QAC5F,oFAAoF;QACpF,4FAA4F;QAC5F,4FAA4F;QAC5F,6FAA6F;QAC7F,mCAAmC;QACnC,CAAC,CAAC,cAAc,EAAE,CAAC;QACnB,IAAI,OAAO;YAAE,OAAO;QACpB,QAAQ,EAAE,CAAC;IACb,CAAC;IAED,SAAS,mBAAmB,CAAC,CAAgC;QAC3D,gGAAgG;QAChG,+FAA+F;QAC/F,8CAA8C;QAC9C,IAAI,OAAO;YAAE,OAAO;QACpB,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,OAAO;YAAE,QAAQ,EAAE,CAAC;IACjD,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,CAAC;AACpF,CAAC"}