@1money/component-ui 0.0.66 → 0.0.67

package/lib/business/Dialog/VerificationDialog/constants.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERIFICATION_DIALOG = void 0;
+var PREFIX = 'om-verification-dialog';
+var VERIFICATION_DIALOG = exports.VERIFICATION_DIALOG = {
+  cls: {
+    wrap: PREFIX,
+    body: "".concat(PREFIX, "-body"),
+    footer: "".concat(PREFIX, "-footer"),
+    actions: "".concat(PREFIX, "-actions"),
+    recovery: "".concat(PREFIX, "-recovery"),
+    recoveryText: "".concat(PREFIX, "-recovery-text"),
+    resend: "".concat(PREFIX, "-resend")
+  },
+  mod: {
+    clickable: 'is-clickable'
+  },
+  // 12px between the copy and the OTP row, 24px between the button row and the
+  // recovery prompt, 12px between the two footer buttons.
+  gap: {
+    body: 12,
+    footer: 24,
+    actions: 12
+  },
+  defaults: {
+    size: 'small',
+    secondaryColor: 'grey',
+    submitText: 'Submit',
+    resendLabel: 'Resend code'
+  },
+  // `Typography.Link` renders an <a> with no href, so Enter/Space activate it.
+  activationKeys: ['Enter', ' ']
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/business/Dialog/VerificationDialog/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useOtpVerification } from './useOtpVerification';
+export { useResendCountdown } from './useResendCountdown';
+export type { OtpVerifyResult, UseOtpVerificationOptions, UseOtpVerificationResult, } from './useOtpVerification';
+export type { UseResendCountdownOptions, UseResendCountdownResult, } from './useResendCountdown';

package/lib/business/Dialog/VerificationDialog/hooks/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useOtpVerification", {
+  enumerable: true,
+  get: function get() {
+    return _useOtpVerification.useOtpVerification;
+  }
+});
+Object.defineProperty(exports, "useResendCountdown", {
+  enumerable: true,
+  get: function get() {
+    return _useResendCountdown.useResendCountdown;
+  }
+});
+var _useOtpVerification = require("./useOtpVerification");
+var _useResendCountdown = require("./useResendCountdown");
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3JjL2J1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvaG9va3MvaW5kZXgudHMiXSwibmFtZXMiOlsiX3VzZU90cFZlcmlmaWNhdGlvbiIsInJlcXVpcmUiLCJfdXNlUmVzZW5kQ291bnRkb3duIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLElBQUFBLG1CQUFBLEdBQUFDLE9BQUE7QUFDQSxJQUFBQyxtQkFBQSxHQUFBRCxPQUFBIiwiZmlsZSI6ImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvaG9va3MvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/lib/business/Dialog/VerificationDialog/hooks/useOtpVerification.d.ts

@@ -0,0 +1,50 @@
+import type { ReactNode } from 'react';
+import type { InputStatus } from "../../../../components/Input";
+/**
+ * Result of an `onVerify` call: `true` for success, or an error-message string
+ * to display under the OTP boxes. Anything other than `true` is treated as a
+ * failure and clears the entered code.
+ */
+export type OtpVerifyResult = boolean | string;
+export interface UseOtpVerificationOptions {
+    /**
+     * Async verifier. Resolve `true` on success; resolve (or return) a string to
+     * show it as the error message. A thrown error uses its `message`, falling
+     * back to a generic message.
+     */
+    onVerify: (code: string) => Promise<OtpVerifyResult> | OtpVerifyResult;
+    /** Controlled OTP value. */
+    value?: string;
+    /** Initial OTP value when uncontrolled. */
+    defaultValue?: string;
+    /** Verify automatically once all digits are entered. @default true */
+    autoSubmit?: boolean;
+    /** Fires on every OTP change with the current value. */
+    onChange?: (value: string) => void;
+}
+export interface UseOtpVerificationResult {
+    /** Current OTP value. */
+    value: string;
+    /** `'error'` while an error message is showing, otherwise `'default'`. */
+    status: InputStatus;
+    /** Error message to render under the boxes, or `undefined` when clear. */
+    feedback: ReactNode;
+    /** `true` while `onVerify` is in flight. */
+    submitting: boolean;
+    /** `true` once all digits are entered. */
+    valid: boolean;
+    /** Wire to the OTP field's `onChange`. */
+    onChange: (value: string) => void;
+    /** Manually trigger verification with the current value. */
+    submit: () => void;
+    /** Clear the current error message. */
+    clearError: () => void;
+    /** Clear both the value and any error. */
+    reset: () => void;
+}
+/**
+ * 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 declare const useOtpVerification: (options: UseOtpVerificationOptions) => UseOtpVerificationResult;

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

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOtpVerification = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _hooks = require("@1money/hooks");
+var __awaiter = void 0 && (void 0).__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());
+  });
+};
+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.
+ */
+var useOtpVerification = exports.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 = (0, _hooks.useControlledState)(defaultValue, value),
+    _useControlledState2 = (0, _slicedToArray2["default"])(_useControlledState, 2),
+    innerValue = _useControlledState2[0],
+    setInnerValue = _useControlledState2[1];
+  var _useState = (0, _react.useState)(false),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    submitting = _useState2[0],
+    setSubmitting = _useState2[1];
+  var _useState3 = (0, _react.useState)(''),
+    _useState4 = (0, _slicedToArray2["default"])(_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 = (0, _react.useRef)(false);
+  var runVerify = (0, _hooks.useEventCallback)(function (code) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var result, _t;
+      return _regenerator["default"].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 = (0, _hooks.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 = (0, _hooks.useEventCallback)(function () {
+    return runVerify(innerValue);
+  });
+  var clearError = (0, _hooks.useEventCallback)(function () {
+    return setError('');
+  });
+  var reset = (0, _hooks.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/src/business/Dialog/VerificationDialog/hooks/useOtpVerification.ts","business/Dialog/VerificationDialog/hooks/useOtpVerification.js"],"names":["_react","require","_hooks","__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","OTP_LENGTH","DEFAULT_ERROR_MESSAGE","STATUS_ERROR","STATUS_DEFAULT","useOtpVerification","exports","options","onVerify","_options$defaultValue","defaultValue","_options$autoSubmit","autoSubmit","onChange","_useControlledState","useControlledState","_useControlledState2","_slicedToArray2","innerValue","setInnerValue","_useState","useState","_useState2","submitting","setSubmitting","_useState3","_useState4","error","setError","submittingRef","useRef","runVerify","useEventCallback","code","_regenerator","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":[null,"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};"],"sourceRoot":"../../../../../../../../../../../src"}

package/lib/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/lib/business/Dialog/VerificationDialog/hooks/useResendCountdown.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useResendCountdown = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _hooks = require("@1money/hooks");
+var __awaiter = void 0 && (void 0).__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());
+  });
+};
+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.
+ */
+var useResendCountdown = exports.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 = (0, _react.useState)(autoStart ? cooldown : 0),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    remaining = _useState2[0],
+    setRemaining = _useState2[1];
+  var _useState3 = (0, _react.useState)(false),
+    _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+    loading = _useState4[0],
+    setLoading = _useState4[1];
+  (0, _react.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 = (0, _hooks.useEventCallback)(function () {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      return _regenerator["default"].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/src/business/Dialog/VerificationDialog/hooks/useResendCountdown.ts","business/Dialog/VerificationDialog/hooks/useResendCountdown.js"],"names":["_react","require","_hooks","__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","DEFAULT_COOLDOWN_SECONDS","SECONDS_PER_MINUTE","TICK_MS","useResendCountdown","exports","options","onResend","_options$cooldown","cooldown","_options$autoStart","autoStart","_useState","useState","_useState2","_slicedToArray2","remaining","setRemaining","_useState3","_useState4","loading","setLoading","useEffect","undefined","timer","setInterval","prev","clearInterval","resend","useEventCallback","_regenerator","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":[null,"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};"],"sourceRoot":"../../../../../../../../../../../src"}

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  VerificationDialog: true,
+  useOtpVerification: true,
+  useResendCountdown: true
+};
+Object.defineProperty(exports, "VerificationDialog", {
+  enumerable: true,
+  get: function get() {
+    return _VerificationDialog.VerificationDialog;
+  }
+});
+Object.defineProperty(exports, "useOtpVerification", {
+  enumerable: true,
+  get: function get() {
+    return _hooks.useOtpVerification;
+  }
+});
+Object.defineProperty(exports, "useResendCountdown", {
+  enumerable: true,
+  get: function get() {
+    return _hooks.useResendCountdown;
+  }
+});
+var _VerificationDialog = require("./VerificationDialog");
+var _hooks = require("./hooks");
+var _interface = require("./interface");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _interface[key];
+    }
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9zcmMvYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9pbmRleC50cyJdLCJuYW1lcyI6WyJfVmVyaWZpY2F0aW9uRGlhbG9nIiwicmVxdWlyZSIsIl9ob29rcyIsIl9pbnRlcmZhY2UiLCJPYmplY3QiLCJrZXlzIiwiZm9yRWFjaCIsImtleSIsInByb3RvdHlwZSIsImhhc093blByb3BlcnR5IiwiY2FsbCIsIl9leHBvcnROYW1lcyIsImV4cG9ydHMiLCJkZWZpbmVQcm9wZXJ0eSIsImVudW1lcmFibGUiLCJnZXQiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxJQUFBQSxtQkFBQSxHQUFBQyxPQUFBO0FBQ0EsSUFBQUMsTUFBQSxHQUFBRCxPQUFBO0FBQ0EsSUFBQUUsVUFBQSxHQUFBRixPQUFBO0FBQUFHLE1BQUEsQ0FBQUMsSUFBQSxDQUFBRixVQUFBLEVBQUFHLE9BQUEsV0FBQUMsR0FBQTtFQUFBLElBQUFBLEdBQUEsa0JBQUFBLEdBQUE7RUFBQSxJQUFBSCxNQUFBLENBQUFJLFNBQUEsQ0FBQUMsY0FBQSxDQUFBQyxJQUFBLENBQUFDLFlBQUEsRUFBQUosR0FBQTtFQUFBLElBQUFBLEdBQUEsSUFBQUssT0FBQSxJQUFBQSxPQUFBLENBQUFMLEdBQUEsTUFBQUosVUFBQSxDQUFBSSxHQUFBO0VBQUFILE1BQUEsQ0FBQVMsY0FBQSxDQUFBRCxPQUFBLEVBQUFMLEdBQUE7SUFBQU8sVUFBQTtJQUFBQyxHQUFBLFdBQUFBLElBQUE7TUFBQSxPQUFBWixVQUFBLENBQUFJLEdBQUE7SUFBQTtFQUFBO0FBQUEiLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/lib/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/lib/business/Dialog/VerificationDialog/interface.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVzaW5lc3MvRGlhbG9nL1ZlcmlmaWNhdGlvbkRpYWxvZy9pbnRlcmZhY2UuanMiLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMiLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvaW50ZXJmYWNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTsiXSwibWFwcGluZ3MiOiIiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/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/lib/business/Dialog/VerificationDialog/style/css.js

@@ -0,0 +1,4 @@
+"use strict";
+
+require("./VerificationDialog.css");
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJ1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3JjL2J1c2luZXNzL0RpYWxvZy9WZXJpZmljYXRpb25EaWFsb2cvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOlsicmVxdWlyZSJdLCJtYXBwaW5ncyI6Ijs7QUFBQUEsT0FBQSIsImZpbGUiOiJidXNpbmVzcy9EaWFsb2cvVmVyaWZpY2F0aW9uRGlhbG9nL3N0eWxlL2Nzcy5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==