@1money/component-ui 0.0.67-alpha.4 → 0.0.68

package/es/business/Dialog/VerificationDialog/hooks/useOtpVerification.js

@@ -0,0 +1,137 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+import { useRef, useState } from 'react';
+import { useControlledState, useEventCallback } from '@1money/hooks';
+var OTP_LENGTH = 6;
+var DEFAULT_ERROR_MESSAGE = 'Incorrect code, please try again.';
+var STATUS_ERROR = 'error';
+var STATUS_DEFAULT = 'default';
+/**
+ * Headless OTP verification logic shared by `VerificationDialog` and any other
+ * shell (popup, inline form, multi-step flow). Owns the value (controlled or
+ * uncontrolled), auto-submit on completion, loading state, and clear-on-error.
+ */
+export var useOtpVerification = function useOtpVerification(options) {
+  var onVerify = options.onVerify,
+    value = options.value,
+    _options$defaultValue = options.defaultValue,
+    defaultValue = _options$defaultValue === void 0 ? '' : _options$defaultValue,
+    _options$autoSubmit = options.autoSubmit,
+    autoSubmit = _options$autoSubmit === void 0 ? true : _options$autoSubmit,
+    onChange = options.onChange;
+  var _useControlledState = useControlledState(defaultValue, value),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    innerValue = _useControlledState2[0],
+    setInnerValue = _useControlledState2[1];
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    submitting = _useState2[0],
+    setSubmitting = _useState2[1];
+  var _useState3 = useState(''),
+    _useState4 = _slicedToArray(_useState3, 2),
+    error = _useState4[0],
+    setError = _useState4[1];
+  // `submitting` drives the UI; `submittingRef` is the synchronous re-entry
+  // guard — auto-submit fires inside `onChange`, which would otherwise double-
+  // fire before the `submitting` state update has flushed.
+  var submittingRef = useRef(false);
+  var runVerify = useEventCallback(function (code) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var result, _t;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!submittingRef.current) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return");
+          case 1:
+            submittingRef.current = true;
+            setSubmitting(true);
+            _context.prev = 2;
+            _context.next = 3;
+            return onVerify(code);
+          case 3:
+            result = _context.sent;
+            if (result !== true) {
+              setError(typeof result === 'string' && result ? result : DEFAULT_ERROR_MESSAGE);
+              setInnerValue('');
+            }
+            _context.next = 5;
+            break;
+          case 4:
+            _context.prev = 4;
+            _t = _context["catch"](2);
+            setError(_t instanceof Error && _t.message ? _t.message : DEFAULT_ERROR_MESSAGE);
+            setInnerValue('');
+          case 5:
+            _context.prev = 5;
+            submittingRef.current = false;
+            setSubmitting(false);
+            return _context.finish(5);
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[2, 4, 5, 6]]);
+    }));
+  });
+  var handleChange = useEventCallback(function (next) {
+    if (error) setError('');
+    setInnerValue(next);
+    onChange === null || onChange === void 0 ? void 0 : onChange(next);
+    if (autoSubmit && next.length === OTP_LENGTH && !submittingRef.current) {
+      runVerify(next);
+    }
+  });
+  var submit = useEventCallback(function () {
+    return runVerify(innerValue);
+  });
+  var clearError = useEventCallback(function () {
+    return setError('');
+  });
+  var reset = useEventCallback(function () {
+    setError('');
+    setInnerValue('');
+  });
+  return {
+    value: innerValue,
+    status: error ? STATUS_ERROR : STATUS_DEFAULT,
+    feedback: error || undefined,
+    submitting: submitting,
+    valid: innerValue.length === OTP_LENGTH,
+    onChange: handleChange,
+    submit: submit,
+    clearError: clearError,
+    reset: reset
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["business/Dialog/VerificationDialog/hooks/useOtpVerification.js","business/Dialog/VerificationDialog/src/business/Dialog/VerificationDialog/hooks/useOtpVerification.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","useRef","useState","useControlledState","useEventCallback","OTP_LENGTH","DEFAULT_ERROR_MESSAGE","STATUS_ERROR","STATUS_DEFAULT","useOtpVerification","options","onVerify","_options$defaultValue","defaultValue","_options$autoSubmit","autoSubmit","onChange","_useControlledState","_useControlledState2","_slicedToArray","innerValue","setInnerValue","_useState","_useState2","submitting","setSubmitting","_useState3","_useState4","error","setError","submittingRef","runVerify","code","_regeneratorRuntime","mark","_callee","_t","wrap","_context","prev","current","abrupt","sent","Error","message","finish","stop","handleChange","length","submit","clearError","reset","status","feedback","undefined","valid"],"mappings":"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","file":"business/Dialog/VerificationDialog/hooks/useOtpVerification.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { useRef, useState } from 'react';\nimport { useControlledState, useEventCallback } from '@1money/hooks';\nconst OTP_LENGTH = 6;\nconst DEFAULT_ERROR_MESSAGE = 'Incorrect code, please try again.';\nconst STATUS_ERROR = 'error';\nconst STATUS_DEFAULT = 'default';\n/**\n * Headless OTP verification logic shared by `VerificationDialog` and any other\n * shell (popup, inline form, multi-step flow). Owns the value (controlled or\n * uncontrolled), auto-submit on completion, loading state, and clear-on-error.\n */\nexport const useOtpVerification = (options) => {\n    const { onVerify, value, defaultValue = '', autoSubmit = true, onChange } = options;\n    const [innerValue, setInnerValue] = useControlledState(defaultValue, value);\n    const [submitting, setSubmitting] = useState(false);\n    const [error, setError] = useState('');\n    // `submitting` drives the UI; `submittingRef` is the synchronous re-entry\n    // guard — auto-submit fires inside `onChange`, which would otherwise double-\n    // fire before the `submitting` state update has flushed.\n    const submittingRef = useRef(false);\n    const runVerify = useEventCallback((code) => __awaiter(void 0, void 0, void 0, function* () {\n        if (submittingRef.current)\n            return;\n        submittingRef.current = true;\n        setSubmitting(true);\n        try {\n            const result = yield onVerify(code);\n            if (result !== true) {\n                setError(typeof result === 'string' && result ? result : DEFAULT_ERROR_MESSAGE);\n                setInnerValue('');\n            }\n        }\n        catch (e) {\n            setError(e instanceof Error && e.message ? e.message : DEFAULT_ERROR_MESSAGE);\n            setInnerValue('');\n        }\n        finally {\n            submittingRef.current = false;\n            setSubmitting(false);\n        }\n    }));\n    const handleChange = useEventCallback((next) => {\n        if (error)\n            setError('');\n        setInnerValue(next);\n        onChange === null || onChange === void 0 ? void 0 : onChange(next);\n        if (autoSubmit && next.length === OTP_LENGTH && !submittingRef.current) {\n            runVerify(next);\n        }\n    });\n    const submit = useEventCallback(() => runVerify(innerValue));\n    const clearError = useEventCallback(() => setError(''));\n    const reset = useEventCallback(() => {\n        setError('');\n        setInnerValue('');\n    });\n    return {\n        value: innerValue,\n        status: error ? STATUS_ERROR : STATUS_DEFAULT,\n        feedback: error || undefined,\n        submitting,\n        valid: innerValue.length === OTP_LENGTH,\n        onChange: handleChange,\n        submit,\n        clearError,\n        reset,\n    };\n};",null],"sourceRoot":"../../../../../../../../../../../src"}

package/es/business/Dialog/VerificationDialog/hooks/useResendCountdown.d.ts

@@ -0,0 +1,26 @@
+export interface UseResendCountdownOptions {
+    /** Fires when the user triggers a resend. */
+    onResend: () => void | Promise<void>;
+    /** Cooldown length in seconds before resending is allowed again. @default 60 */
+    cooldown?: number;
+    /** Start the cooldown immediately on mount. @default false */
+    autoStart?: boolean;
+}
+export interface UseResendCountdownResult {
+    /** Seconds left in the current cooldown (`0` when resending is allowed). */
+    remaining: number;
+    /** `true` when a resend can be triggered (no cooldown, not loading). */
+    canResend: boolean;
+    /** `true` while `onResend` is in flight. */
+    loading: boolean;
+    /** Human-readable countdown, e.g. `"1m 0s"`. */
+    formatted: string;
+    /** Trigger a resend (no-op during cooldown or while loading). */
+    resend: () => void;
+}
+/**
+ * Headless resend-with-cooldown logic ported from the product's `ResendButton`:
+ * a per-second countdown, a lock during the cooldown and while the resend
+ * request is in flight, and an `m s` formatter.
+ */
+export declare const useResendCountdown: (options: UseResendCountdownOptions) => UseResendCountdownResult;

package/es/business/Dialog/VerificationDialog/hooks/useResendCountdown.js

@@ -0,0 +1,103 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+import { useEffect, useState } from 'react';
+import { useEventCallback } from '@1money/hooks';
+var DEFAULT_COOLDOWN_SECONDS = 60;
+var SECONDS_PER_MINUTE = 60;
+var TICK_MS = 1000;
+/**
+ * Headless resend-with-cooldown logic ported from the product's `ResendButton`:
+ * a per-second countdown, a lock during the cooldown and while the resend
+ * request is in flight, and an `m s` formatter.
+ */
+export var useResendCountdown = function useResendCountdown(options) {
+  var onResend = options.onResend,
+    _options$cooldown = options.cooldown,
+    cooldown = _options$cooldown === void 0 ? DEFAULT_COOLDOWN_SECONDS : _options$cooldown,
+    _options$autoStart = options.autoStart,
+    autoStart = _options$autoStart === void 0 ? false : _options$autoStart;
+  var _useState = useState(autoStart ? cooldown : 0),
+    _useState2 = _slicedToArray(_useState, 2),
+    remaining = _useState2[0],
+    setRemaining = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    loading = _useState4[0],
+    setLoading = _useState4[1];
+  useEffect(function () {
+    if (remaining <= 0) return undefined;
+    var timer = setInterval(function () {
+      setRemaining(function (prev) {
+        return prev <= 1 ? 0 : prev - 1;
+      });
+    }, TICK_MS);
+    return function () {
+      return clearInterval(timer);
+    };
+  }, [remaining]);
+  var resend = useEventCallback(function () {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(remaining > 0 || loading)) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return");
+          case 1:
+            setLoading(true);
+            _context.prev = 2;
+            _context.next = 3;
+            return onResend();
+          case 3:
+            setRemaining(cooldown);
+          case 4:
+            _context.prev = 4;
+            setLoading(false);
+            return _context.finish(4);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[2,, 4, 5]]);
+    }));
+  });
+  var minutes = Math.floor(remaining / SECONDS_PER_MINUTE);
+  var seconds = remaining % SECONDS_PER_MINUTE;
+  return {
+    remaining: remaining,
+    canResend: remaining <= 0 && !loading,
+    loading: loading,
+    formatted: "".concat(minutes, "m ").concat(seconds, "s"),
+    resend: resend
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["business/Dialog/VerificationDialog/hooks/useResendCountdown.js","business/Dialog/VerificationDialog/src/business/Dialog/VerificationDialog/hooks/useResendCountdown.ts"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","useEffect","useState","useEventCallback","DEFAULT_COOLDOWN_SECONDS","SECONDS_PER_MINUTE","TICK_MS","useResendCountdown","options","onResend","_options$cooldown","cooldown","_options$autoStart","autoStart","_useState","_useState2","_slicedToArray","remaining","setRemaining","_useState3","_useState4","loading","setLoading","undefined","timer","setInterval","prev","clearInterval","resend","_regeneratorRuntime","mark","_callee","wrap","_context","abrupt","finish","stop","minutes","Math","floor","seconds","canResend","formatted","concat"],"mappings":"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","file":"business/Dialog/VerificationDialog/hooks/useResendCountdown.js","sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { useEffect, useState } from 'react';\nimport { useEventCallback } from '@1money/hooks';\nconst DEFAULT_COOLDOWN_SECONDS = 60;\nconst SECONDS_PER_MINUTE = 60;\nconst TICK_MS = 1000;\n/**\n * Headless resend-with-cooldown logic ported from the product's `ResendButton`:\n * a per-second countdown, a lock during the cooldown and while the resend\n * request is in flight, and an `m s` formatter.\n */\nexport const useResendCountdown = (options) => {\n    const { onResend, cooldown = DEFAULT_COOLDOWN_SECONDS, autoStart = false } = options;\n    const [remaining, setRemaining] = useState(autoStart ? cooldown : 0);\n    const [loading, setLoading] = useState(false);\n    useEffect(() => {\n        if (remaining <= 0)\n            return undefined;\n        const timer = setInterval(() => {\n            setRemaining((prev) => (prev <= 1 ? 0 : prev - 1));\n        }, TICK_MS);\n        return () => clearInterval(timer);\n    }, [remaining]);\n    const resend = useEventCallback(() => __awaiter(void 0, void 0, void 0, function* () {\n        if (remaining > 0 || loading)\n            return;\n        setLoading(true);\n        try {\n            yield onResend();\n            setRemaining(cooldown);\n        }\n        finally {\n            setLoading(false);\n        }\n    }));\n    const minutes = Math.floor(remaining / SECONDS_PER_MINUTE);\n    const seconds = remaining % SECONDS_PER_MINUTE;\n    return {\n        remaining,\n        canResend: remaining <= 0 && !loading,\n        loading,\n        formatted: `${minutes}m ${seconds}s`,\n        resend,\n    };\n};",null],"sourceRoot":"../../../../../../../../../../../src"}

package/es/business/Dialog/VerificationDialog/index.d.ts

@@ -0,0 +1,3 @@
+export { VerificationDialog } from './VerificationDialog';
+export { useOtpVerification, useResendCountdown } from './hooks';
+export * from './interface';

package/es/business/Dialog/VerificationDialog/index.js

@@ -0,0 +1,4 @@
+export { VerificationDialog } from './VerificationDialog';
+export { useOtpVerification, useResendCountdown } from './hooks';
+export * from './interface';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9zcmMvYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9pbmRleC50cyJdLCJuYW1lcyI6WyJWZXJpZmljYXRpb25EaWFsb2ciLCJ1c2VPdHBWZXJpZmljYXRpb24iLCJ1c2VSZXNlbmRDb3VudGRvd24iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGtCQUFrQixRQUFRLHNCQUFzQjtBQUN6RCxTQUFTQyxrQkFBa0IsRUFBRUMsa0JBQWtCLFFBQVEsU0FBUztBQUNoRSxjQUFjLGFBQWEiLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/business/Dialog/VerificationDialog/interface.d.ts

@@ -0,0 +1,124 @@
+import type { ReactNode } from 'react';
+import type { ButtonColor } from "../../../components/Button";
+import type { DialogProps } from "../../../components/Dialog";
+import type { InputStatus } from "../../../components/Input";
+import type { OtpVerifyResult } from './hooks';
+export type { OtpVerifyResult, UseOtpVerificationOptions, UseOtpVerificationResult, UseResendCountdownOptions, UseResendCountdownResult, } from './hooks';
+/** Visual status forwarded to the inner `Input.OTP`. */
+export type VerificationDialogStatus = InputStatus;
+/**
+ * Optional secondary button (e.g. "Cancel" / "Back") rendered to the left of
+ * the primary submit button. When omitted, the submit button spans the full
+ * width; when present, the two split the row evenly.
+ */
+export interface VerificationDialogSecondaryAction {
+    /** Button label. */
+    label: ReactNode;
+    /** Click handler. */
+    onClick?: () => void;
+    /** Disable the button. */
+    disabled?: boolean;
+    /**
+     * Color tone.
+     * @default 'grey'
+     */
+    color?: ButtonColor;
+}
+/**
+ * Optional "Haven't received the code? Resend" row below a divider in the
+ * footer. Resending is rate-limited by an internal countdown.
+ */
+export interface VerificationDialogResend {
+    /** Muted prompt text, e.g. `"Haven't received the code?"`. */
+    promptText?: ReactNode;
+    /**
+     * Trailing brand-colored action text.
+     * @default 'Resend code'
+     */
+    actionText?: ReactNode;
+    /** Fires when the user triggers a resend (in-app action like re-sending an email). */
+    onResend: () => void | Promise<void>;
+    /**
+     * Cooldown length in seconds before resending is allowed again. While
+     * counting down, the label is muted and shows the remaining time.
+     * @default 60
+     */
+    cooldown?: number;
+}
+export interface VerificationDialogProps extends Pick<DialogProps, 'open' | 'size' | 'maskClosable' | 'showCloseIcon' | 'showBackIcon' | 'onBack' | 'className'> {
+    /** Dialog heading, e.g. `"Two-factor authenticator"` / `"Email Verification"`. */
+    title: ReactNode;
+    /** Supporting copy under the title explaining what code to enter and why. */
+    description?: ReactNode;
+    /** Controlled OTP value. */
+    value?: string;
+    /** Initial OTP value when uncontrolled. */
+    defaultValue?: string;
+    /** Helper subtext shown directly under the OTP boxes, e.g. `"e.g. 123 456"`. Hidden while an error is showing. */
+    otpHint?: ReactNode;
+    /**
+     * Auto-focus the first OTP box when the dialog opens.
+     * @default false
+     */
+    autoFocus?: boolean;
+    /**
+     * Mask the entered digits as dots (•), like a password field, instead of
+     * showing them in plain text. This is **display only** — `value`, `onChange`,
+     * and the code passed to `onVerify` are always the real digits. Use it when
+     * the screen may be visible to others (e.g. shared/public devices).
+     * @default false
+     */
+    mask?: boolean;
+    /**
+     * Disable OTP entry.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Verify automatically once all digits are entered (in addition to the
+     * submit button).
+     * @default true
+     */
+    autoSubmit?: boolean;
+    /**
+     * Verify the entered code. Resolve `true` on success; resolve (or return) a
+     * string to show it as the error message under the boxes. On any non-`true`
+     * result (or a thrown error) the boxes are cleared. Drives the submit
+     * button's loading state and auto-submit.
+     *
+     * @example
+     * ```tsx
+     * <VerificationDialog
+     *   open={open}
+     *   title="Email Verification"
+     *   description="Enter the 6-digit code sent to ema...@gmail.com"
+     *   otpHint="e.g. 123 456"
+     *   submitText="Continue"
+     *   onVerify={async (code) => {
+     *     const res = await api.verify(code);
+     *     return res.ok ? true : 'That code is incorrect.';
+     *   }}
+     *   secondaryAction={{ label: 'Cancel', onClick: () => setOpen(false) }}
+     *   resend={{ promptText: "Haven't received the code?", onResend: api.resend, cooldown: 60 }}
+     *   onClose={() => setOpen(false)}
+     * />
+     * ```
+     */
+    onVerify: (code: string) => Promise<OtpVerifyResult> | OtpVerifyResult;
+    /** Fires on every OTP change with the current value. */
+    onChange?: (value: string) => void;
+    /**
+     * Primary (submit) button label.
+     * @default 'Submit'
+     */
+    submitText?: ReactNode;
+    /** Optional secondary button (e.g. "Cancel") shown beside the submit button. */
+    secondaryAction?: VerificationDialogSecondaryAction;
+    /** Optional resend prompt + link with built-in cooldown, below a divider. */
+    resend?: VerificationDialogResend;
+    /**
+     * Fires from the close icon, mask click, and Escape key. Set your `open`
+     * state to `false` here.
+     */
+    onClose?: () => void;
+}

package/es/business/Dialog/VerificationDialog/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9pbnRlcmZhY2UuanMiLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMiLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvaW50ZXJmYWNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTsiXSwibWFwcGluZ3MiOiJBQUFBIiwiaWdub3JlTGlzdCI6W119

package/es/business/Dialog/VerificationDialog/style/VerificationDialog.css

@@ -0,0 +1,30 @@
+/**
+  * Retrieves the spacing value for a given token key.
+  *
+  * @param {string} $key - The spacing token key (e.g., '100', '200').
+  * @return {length|null} The computed spacing value or null if the key is invalid.
+  * @example
+  *   .element {
+  *     padding: om-spacing-token('200'); // Returns 8px if $om-sys-spacing-unit is 4px
+  *   }
+  */
+/**
+  * Computes the spacing value based on a token key or a direct length value.
+  *
+  * @param {string|length} $value - The spacing token key (e.g., '100') or a direct length value (e.g., '16px').
+  * @return {length} The computed spacing value.
+  * @example
+  *   .element {
+  *     margin: om-spacing-value('300'); // Returns 12px if $om-sys-spacing-unit is 4px
+  *     padding: om-spacing-value(16px); // Returns 16px
+  *     gap: om-spacing-value(2); // Returns 8px if $om-sys-spacing-unit is 4px
+  *   }
+  */
+.om-verification-dialog-actions > button {
+  flex: 1 1 0;
+}
+
+.om-verification-dialog-recovery-text.is-clickable,
+.om-verification-dialog-resend.is-clickable {
+  cursor: pointer;
+}

package/es/business/Dialog/VerificationDialog/style/css.js

@@ -0,0 +1,2 @@
+import './VerificationDialog.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3JjL2J1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywyQkFBMkIiLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9zdHlsZS9jc3MuanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/business/Dialog/VerificationDialog/style/index.d.ts

@@ -0,0 +1 @@
+import './VerificationDialog.css';

package/es/business/Dialog/VerificationDialog/style/index.js

@@ -0,0 +1,2 @@
+import './VerificationDialog.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3JjL2J1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTywyQkFBMkIiLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9zdHlsZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/business/Dialog/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ResultDialog';
+export * from './TransactionDialog';
+export * from './VerificationDialog';

package/es/business/Dialog/index.js

@@ -0,0 +1,4 @@
+export * from './ResultDialog';
+export * from './TransactionDialog';
+export * from './VerificationDialog';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL3NyYy9idXNpbmVzcy9EaWFsb2cvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0I7QUFDOUIsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyxzQkFBc0IiLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/business/Filter/Account/Account.js

@@ -286,4 +286,4 @@ var AccountFilterBase = function AccountFilterBase(_a) {
   }));
 };
 export var AccountFilter = /*#__PURE__*/memo(AccountFilterBase);
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["business/Filter/Account/Account.js","business/Filter/src/business/Filter/Account/Account.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","memo","useCallback","useImperativeHandle","useMemo","useState","Button","Checkbox","Empty","Flex","Icons","Select","Tag","TypographyBody","TypographyLabel","joinCls","WRAP_CLS","PANEL_CLS","concat","MAIN_TAG","RESET_LABEL","APPLY_LABEL","DEFAULT_ALL_LABEL","DEFAULT_PLACEHOLDER","DEFAULT_SEARCH_PLACEHOLDER","DEFAULT_EMPTY","variant","icon","name","size","color","title","description","style","padding","MORE_SUFFIX","count","FULL_WIDTH_STYLE","flex","toOption","item","hasName","customerName","label","accountId","value","undefined","tag","isMain","searchText","join","AccountFilterBase","_a","ref","className","_a$size","_a$placeholder","placeholder","data","_a$allLabel","allLabel","_a$search","search","_a$searchPlaceholder","searchPlaceholder","_a$searchEmpty","searchEmpty","onApply","onReset","rest","options","map","optionByValue","Map","forEach","option","set","_useState","_useState2","_slicedToArray","open","setOpen","_useState3","_useState4","keyword","setKeyword","_useState5","_useState6","temp","setTemp","_useState7","_useState8","committed","setCommitted","allChecked","searching","trim","filterOption","searchValue","term","toLowerCase","mapped","includes","clear","reset","handleSelectChange","next","nextValues","Array","isArray","String","collapse","handleAllClick","handleApply","handleReset","handleOpenChange","nextOpen","renderRow","checked","align","justify","gap","children","vertical","readOnly","renderValue","first","get","firstLabel","extra","assign","multiple","panelClassName","onOpenChange","onChange","searchable","onSearchChange","panelHeader","type","onClick","emptyContent","renderOption","meta","selected","panelFooter","AccountFilter"],"mappings":"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","file":"business/Filter/Account/Account.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo, useCallback, useImperativeHandle, useMemo, useState } from 'react';\nimport { Button } from '../../../components/Button';\nimport { Checkbox } from '../../../components/Checkbox';\nimport { Empty } from '../../../components/Empty';\nimport { Flex } from '../../../components/Flex';\nimport { Icons } from '../../../components/Icons';\nimport { Select } from '../../../components/Select';\nimport { Tag } from '../../../components/Tag';\nimport { TypographyBody, TypographyLabel } from '../../../components/Typography';\nimport { joinCls } from '../../../utils/classnames';\nconst WRAP_CLS = 'om-account-filter';\n// The panel is portaled to <body>, so panel-scoped overrides are keyed off this\n// class (passed as `panelClassName`) rather than the trigger root.\nconst PANEL_CLS = `${WRAP_CLS}-panel`;\nconst MAIN_TAG = 'Main';\nconst RESET_LABEL = 'Reset';\nconst APPLY_LABEL = 'Apply';\nconst DEFAULT_ALL_LABEL = 'All accounts';\nconst DEFAULT_PLACEHOLDER = 'Account';\nconst DEFAULT_SEARCH_PLACEHOLDER = 'Search by name or #';\nconst DEFAULT_EMPTY = (_jsx(Empty, { variant: 'fill', icon: _jsx(Icons, { name: 'search', size: 16, color: 'currentColor' }), title: 'No accounts found', description: 'Try a different name or adjust your search filters.', style: { padding: 0 } }));\nconst MORE_SUFFIX = (count) => `+ ${count} more`;\nconst FULL_WIDTH_STYLE = { flex: 1 };\n// Named account → two-line row (name + id). Unnamed account → single line with\n// the id as the title, so the id never appears twice.\nconst toOption = (item) => {\n    const hasName = !!item.customerName;\n    const label = hasName ? item.customerName : item.accountId;\n    return {\n        label,\n        value: item.accountId,\n        description: hasName ? item.accountId : undefined,\n        tag: item.isMain ? MAIN_TAG : undefined,\n        // Match name + id regardless of which line they render on.\n        searchText: [label, item.accountId].join(' '),\n    };\n};\nconst AccountFilterBase = (_a) => {\n    var { ref, className, size = 'small', label, placeholder = DEFAULT_PLACEHOLDER, data, allLabel = DEFAULT_ALL_LABEL, search = true, searchPlaceholder = DEFAULT_SEARCH_PLACEHOLDER, searchEmpty = DEFAULT_EMPTY, onApply, onReset } = _a, rest = __rest(_a, [\"ref\", \"className\", \"size\", \"label\", \"placeholder\", \"data\", \"allLabel\", \"search\", \"searchPlaceholder\", \"searchEmpty\", \"onApply\", \"onReset\"]);\n    const options = useMemo(() => data.map(toOption), [data]);\n    const optionByValue = useMemo(() => {\n        const map = new Map();\n        options.forEach((option) => map.set(option.value, option));\n        return map;\n    }, [options]);\n    const [open, setOpen] = useState(false);\n    const [keyword, setKeyword] = useState('');\n    // `temp` is the in-panel draft; `committed` is the last Applied selection.\n    // Only Apply promotes `temp` → `committed` and notifies the parent. With an\n    // \"All accounts\" row, \"all selected\" is represented by an empty array.\n    const [temp, setTemp] = useState([]);\n    const [committed, setCommitted] = useState([]);\n    // The \"All accounts\" row is checked exactly when nothing specific is selected.\n    const allChecked = temp.length === 0;\n    // While searching, the \"All accounts\" row is meaningless — hide it so a\n    // no-match search shows the empty state instead of a lone \"All accounts\".\n    const searching = search && keyword.trim().length > 0;\n    const filterOption = useCallback((searchValue, option) => {\n        const term = searchValue.trim().toLowerCase();\n        if (!term)\n            return true;\n        const mapped = option;\n        return typeof mapped.searchText === 'string'\n            ? mapped.searchText.toLowerCase().includes(term)\n            : false;\n    }, []);\n    useImperativeHandle(ref, () => ({\n        clear: () => {\n            setTemp([]);\n            setCommitted([]);\n        },\n        reset: () => {\n            setTemp([]);\n            setCommitted([]);\n            onReset === null || onReset === void 0 ? void 0 : onReset([]);\n        },\n    }), [onReset]);\n    const handleSelectChange = useCallback((next) => {\n        const nextValues = (Array.isArray(next) ? next : []).map(String);\n        // Selecting every concrete account collapses to \"all\" ([]), matching the\n        // backend convention that empty == no filter.\n        const collapse = nextValues.length === options.length;\n        setTemp(collapse ? [] : nextValues);\n    }, [options]);\n    const handleAllClick = useCallback(() => {\n        // The \"All accounts\" row is exclusive: turning it on clears specific picks.\n        setTemp([]);\n    }, []);\n    const handleApply = useCallback(() => {\n        setCommitted(temp);\n        onApply(temp);\n        setOpen(false);\n    }, [temp, onApply]);\n    const handleReset = useCallback(() => {\n        setTemp([]);\n        setCommitted([]);\n        onReset === null || onReset === void 0 ? void 0 : onReset([]);\n    }, [onReset]);\n    const handleOpenChange = useCallback((nextOpen) => {\n        setOpen(nextOpen);\n        if (nextOpen)\n            return;\n        // Closing without Apply discards the draft.\n        setTemp(committed);\n        setKeyword('');\n    }, [committed]);\n    const renderRow = useCallback((option, checked) => {\n        return (_jsxs(Flex, { align: 'center', justify: 'space-between', gap: 8, className: `${WRAP_CLS}__row`, children: [_jsxs(Flex, { vertical: true, gap: 0, align: 'start', className: `${WRAP_CLS}__row-text`, children: [_jsxs(Flex, { align: 'center', gap: 8, className: `${WRAP_CLS}__row-line`, children: [_jsx(TypographyLabel, { size: 'md', className: `${WRAP_CLS}__row-name`, children: option.label }), option.tag && _jsx(Tag, { label: option.tag, size: 'small', color: 'recommended' })] }), option.description && (_jsx(TypographyBody, { size: 'sm', color: 'default-tertiary', children: option.description }))] }), _jsx(Checkbox, { checked: checked, readOnly: true, className: `${WRAP_CLS}__row-check` })] }));\n    }, []);\n    // The trigger reflects the COMMITTED selection (not the in-panel draft).\n    // `renderValue` short-circuits Select's own placeholder handling, so the\n    // empty state must return the \"All accounts\" text explicitly.\n    const renderValue = useCallback(() => {\n        // The trigger reflects the COMMITTED selection only — `temp` is the in-panel\n        // draft and must not leak into the trigger before Apply. An empty\n        // `committed` means \"All accounts\".\n        if (committed.length === 0) {\n            // \"All accounts\" is the default filter value, not an empty placeholder.\n            // The trigger's empty `value` makes Select wrap this in its grey\n            // placeholder class, so force the default dark text to match DateRange.\n            return (_jsx(TypographyBody, { size: 'md', color: 'default', className: `${WRAP_CLS}__value`, children: allLabel }));\n        }\n        const first = optionByValue.get(committed[0]);\n        const firstLabel = first ? first.label : committed[0];\n        const extra = committed.length - 1;\n        return (_jsxs(TypographyBody, { size: 'md', className: `${WRAP_CLS}__value`, children: [_jsx(\"span\", { className: `${WRAP_CLS}__value-label`, children: firstLabel }), extra > 0 && _jsx(\"span\", { className: `${WRAP_CLS}__value-more`, children: MORE_SUFFIX(extra) })] }));\n    }, [allLabel, committed, optionByValue]);\n    return (_jsx(Select, Object.assign({}, rest, { multiple: true, size: size, label: label, placeholder: placeholder, className: joinCls(WRAP_CLS, className), panelClassName: PANEL_CLS, value: temp, open: open, onOpenChange: handleOpenChange, onChange: handleSelectChange, searchable: search, searchPlaceholder: searchPlaceholder, searchValue: keyword, onSearchChange: setKeyword, filterOption: filterOption, options: options, panelHeader: searching ? undefined : (_jsxs(\"button\", { type: 'button', className: joinCls(`${WRAP_CLS}__all`, allChecked && `${WRAP_CLS}__all--checked`), onClick: handleAllClick, children: [_jsx(TypographyLabel, { size: 'md', children: allLabel }), _jsx(Checkbox, { checked: allChecked, readOnly: true, className: `${WRAP_CLS}__row-check` })] })), emptyContent: searchEmpty, renderValue: renderValue, renderOption: (option, meta) => renderRow(option, meta.selected), panelFooter: _jsxs(Flex, { gap: 8, className: `${WRAP_CLS}__footer`, children: [_jsx(Button, { color: 'grey', size: 'small', style: FULL_WIDTH_STYLE, onClick: handleReset, children: RESET_LABEL }), _jsx(Button, { color: 'primary', size: 'small', style: FULL_WIDTH_STYLE, onClick: handleApply, children: APPLY_LABEL })] }) })));\n};\nexport const AccountFilter = memo(AccountFilterBase);",null],"sourceRoot":"../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["business/Filter/Account/Account.js","business/Filter/src/business/Filter/Account/Account.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","memo","useCallback","useImperativeHandle","useMemo","useState","Button","Checkbox","Empty","Flex","Icons","Select","Tag","TypographyBody","TypographyLabel","joinCls","WRAP_CLS","PANEL_CLS","concat","MAIN_TAG","RESET_LABEL","APPLY_LABEL","DEFAULT_ALL_LABEL","DEFAULT_PLACEHOLDER","DEFAULT_SEARCH_PLACEHOLDER","DEFAULT_EMPTY","variant","icon","name","size","color","title","description","style","padding","MORE_SUFFIX","count","FULL_WIDTH_STYLE","flex","toOption","item","hasName","customerName","label","accountId","value","undefined","tag","isMain","searchText","join","AccountFilterBase","_a","ref","className","_a$size","_a$placeholder","placeholder","data","_a$allLabel","allLabel","_a$search","search","_a$searchPlaceholder","searchPlaceholder","_a$searchEmpty","searchEmpty","onApply","onReset","rest","options","map","optionByValue","Map","forEach","option","set","_useState","_useState2","_slicedToArray","open","setOpen","_useState3","_useState4","keyword","setKeyword","_useState5","_useState6","temp","setTemp","_useState7","_useState8","committed","setCommitted","allChecked","searching","trim","filterOption","searchValue","term","toLowerCase","mapped","includes","clear","reset","handleSelectChange","next","nextValues","Array","isArray","String","collapse","handleAllClick","handleApply","handleReset","handleOpenChange","nextOpen","renderRow","checked","align","justify","gap","children","vertical","readOnly","renderValue","first","get","firstLabel","extra","assign","multiple","panelClassName","onOpenChange","onChange","searchable","onSearchChange","panelHeader","type","onClick","emptyContent","renderOption","meta","selected","panelFooter","AccountFilter"],"mappings":"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","file":"business/Filter/Account/Account.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo, useCallback, useImperativeHandle, useMemo, useState } from 'react';\nimport { Button } from '../../../components/Button';\nimport { Checkbox } from '../../../components/Checkbox';\nimport { Empty } from '../../../components/Empty';\nimport { Flex } from '../../../components/Flex';\nimport { Icons } from '../../../components/Icons';\nimport { Select } from '../../../components/Select';\nimport { Tag } from '../../../components/Tag';\nimport { TypographyBody, TypographyLabel } from '../../../components/Typography';\nimport { joinCls } from '../../../utils/classnames';\nconst WRAP_CLS = 'om-account-filter';\n// The panel is portaled to <body>, so panel-scoped overrides are keyed off this\n// class (passed as `panelClassName`) rather than the trigger root.\nconst PANEL_CLS = `${WRAP_CLS}-panel`;\nconst MAIN_TAG = 'Main';\nconst RESET_LABEL = 'Reset';\nconst APPLY_LABEL = 'Apply';\nconst DEFAULT_ALL_LABEL = 'All accounts';\nconst DEFAULT_PLACEHOLDER = 'Account';\nconst DEFAULT_SEARCH_PLACEHOLDER = 'Search by name or #';\nconst DEFAULT_EMPTY = (_jsx(Empty, { variant: 'fill', icon: _jsx(Icons, { name: 'search', size: 16, color: 'currentColor' }), title: 'No accounts found', description: 'Try a different name or adjust your search filters.', style: { padding: 0 } }));\nconst MORE_SUFFIX = (count) => `+ ${count} more`;\nconst FULL_WIDTH_STYLE = { flex: 1 };\n// Named account → two-line row (name + id). Unnamed account → single line with\n// the id as the title, so the id never appears twice.\nconst toOption = (item) => {\n    const hasName = !!item.customerName;\n    const label = hasName ? item.customerName : item.accountId;\n    return {\n        label,\n        value: item.accountId,\n        description: hasName ? item.accountId : undefined,\n        tag: item.isMain ? MAIN_TAG : undefined,\n        // Match name + id regardless of which line they render on.\n        searchText: [label, item.accountId].join(' '),\n    };\n};\nconst AccountFilterBase = (_a) => {\n    var { ref, className, size = 'small', label, placeholder = DEFAULT_PLACEHOLDER, data, allLabel = DEFAULT_ALL_LABEL, search = true, searchPlaceholder = DEFAULT_SEARCH_PLACEHOLDER, searchEmpty = DEFAULT_EMPTY, onApply, onReset } = _a, rest = __rest(_a, [\"ref\", \"className\", \"size\", \"label\", \"placeholder\", \"data\", \"allLabel\", \"search\", \"searchPlaceholder\", \"searchEmpty\", \"onApply\", \"onReset\"]);\n    const options = useMemo(() => data.map(toOption), [data]);\n    const optionByValue = useMemo(() => {\n        const map = new Map();\n        options.forEach((option) => map.set(option.value, option));\n        return map;\n    }, [options]);\n    const [open, setOpen] = useState(false);\n    const [keyword, setKeyword] = useState('');\n    // `temp` is the in-panel draft; `committed` is the last Applied selection.\n    // Only Apply promotes `temp` → `committed` and notifies the parent. With an\n    // \"All accounts\" row, \"all selected\" is represented by an empty array.\n    const [temp, setTemp] = useState([]);\n    const [committed, setCommitted] = useState([]);\n    // The \"All accounts\" row is checked exactly when nothing specific is selected.\n    const allChecked = temp.length === 0;\n    // While searching, the \"All accounts\" row is meaningless — hide it so a\n    // no-match search shows the empty state instead of a lone \"All accounts\".\n    const searching = search && keyword.trim().length > 0;\n    const filterOption = useCallback((searchValue, option) => {\n        const term = searchValue.trim().toLowerCase();\n        if (!term)\n            return true;\n        const mapped = option;\n        return typeof mapped.searchText === 'string'\n            ? mapped.searchText.toLowerCase().includes(term)\n            : false;\n    }, []);\n    useImperativeHandle(ref, () => ({\n        clear: () => {\n            setTemp([]);\n            setCommitted([]);\n        },\n        reset: () => {\n            setTemp([]);\n            setCommitted([]);\n            onReset === null || onReset === void 0 ? void 0 : onReset([]);\n        },\n    }), [onReset]);\n    const handleSelectChange = useCallback((next) => {\n        const nextValues = (Array.isArray(next) ? next : []).map(String);\n        // Selecting every concrete account collapses to \"all\" ([]), matching the\n        // backend convention that empty == no filter.\n        const collapse = nextValues.length === options.length;\n        setTemp(collapse ? [] : nextValues);\n    }, [options]);\n    const handleAllClick = useCallback(() => {\n        // The \"All accounts\" row is exclusive: turning it on clears specific picks.\n        setTemp([]);\n    }, []);\n    const handleApply = useCallback(() => {\n        setCommitted(temp);\n        onApply(temp);\n        setOpen(false);\n    }, [temp, onApply]);\n    const handleReset = useCallback(() => {\n        setTemp([]);\n        setCommitted([]);\n        onReset === null || onReset === void 0 ? void 0 : onReset([]);\n    }, [onReset]);\n    const handleOpenChange = useCallback((nextOpen) => {\n        setOpen(nextOpen);\n        if (nextOpen)\n            return;\n        // Closing without Apply discards the draft.\n        setTemp(committed);\n        setKeyword('');\n    }, [committed]);\n    const renderRow = useCallback((option, checked) => {\n        return (_jsxs(Flex, { align: 'center', justify: 'space-between', gap: 8, className: `${WRAP_CLS}__row`, children: [_jsxs(Flex, { vertical: true, gap: 0, align: 'start', className: `${WRAP_CLS}__row-text`, children: [_jsxs(Flex, { align: 'center', gap: 8, className: `${WRAP_CLS}__row-line`, children: [_jsx(TypographyLabel, { size: 'md', className: `${WRAP_CLS}__row-name`, children: option.label }), option.tag && _jsx(Tag, { label: option.tag, size: 'small', color: 'recommended' })] }), option.description && (_jsx(TypographyBody, { size: 'sm', color: 'default-tertiary', children: option.description }))] }), _jsx(Checkbox, { checked: checked, readOnly: true, className: `${WRAP_CLS}__row-check` })] }));\n    }, []);\n    // The trigger reflects the COMMITTED selection (not the in-panel draft).\n    // `renderValue` short-circuits Select's own placeholder handling, so the\n    // empty state must return the \"All accounts\" text explicitly.\n    const renderValue = useCallback(() => {\n        // The trigger reflects the COMMITTED selection only — `temp` is the in-panel\n        // draft and must not leak into the trigger before Apply. An empty\n        // `committed` means \"All accounts\".\n        if (committed.length === 0) {\n            // \"All accounts\" is the default filter value, not an empty placeholder.\n            // The trigger's empty `value` makes Select wrap this in its grey\n            // placeholder class, so force the default dark text to match DateRange.\n            return (_jsx(TypographyBody, { size: 'md', color: 'default', className: `${WRAP_CLS}__value`, children: allLabel }));\n        }\n        const first = optionByValue.get(committed[0]);\n        const firstLabel = first ? first.label : committed[0];\n        const extra = committed.length - 1;\n        return (_jsxs(TypographyBody, { size: 'md', className: `${WRAP_CLS}__value`, children: [_jsx(\"span\", { className: `${WRAP_CLS}__value-label`, children: firstLabel }), extra > 0 && _jsx(\"span\", { className: `${WRAP_CLS}__value-more`, children: MORE_SUFFIX(extra) })] }));\n    }, [allLabel, committed, optionByValue]);\n    return (_jsx(Select, Object.assign({}, rest, { multiple: true, size: size, label: label, placeholder: placeholder, className: joinCls(WRAP_CLS, className), panelClassName: PANEL_CLS, value: temp, open: open, onOpenChange: handleOpenChange, onChange: handleSelectChange, searchable: search, searchPlaceholder: searchPlaceholder, searchValue: keyword, onSearchChange: setKeyword, filterOption: filterOption, options: options, panelHeader: searching ? undefined : (_jsxs(\"button\", { type: 'button', className: joinCls(`${WRAP_CLS}__all`, allChecked && `${WRAP_CLS}__all--checked`), onClick: handleAllClick, children: [_jsx(TypographyLabel, { size: 'md', children: allLabel }), _jsx(Checkbox, { checked: allChecked, readOnly: true, className: `${WRAP_CLS}__row-check` })] })), emptyContent: searchEmpty, renderValue: renderValue, renderOption: (option, meta) => renderRow(option, meta.selected), panelFooter: _jsxs(Flex, { gap: 8, className: `${WRAP_CLS}__footer`, children: [_jsx(Button, { color: 'grey', size: 'small', style: FULL_WIDTH_STYLE, onClick: handleReset, children: RESET_LABEL }), _jsx(Button, { color: 'primary', size: 'small', style: FULL_WIDTH_STYLE, onClick: handleApply, children: APPLY_LABEL })] }) })));\n};\nexport const AccountFilter = memo(AccountFilterBase);",null],"sourceRoot":"../../../../../../../../../../src"}