@cerberus-design/react 0.23.0 → 0.24.0

package/dist/node_modules/.pnpm/@zag-js_pin-input@1.29.1/node_modules/@zag-js/pin-input/dist/index.cjs

@@ -0,0 +1,532 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index$3 = require('../../../../../@zag-js_anatomy@1.29.1/node_modules/@zag-js/anatomy/dist/index.cjs');
+const index$1 = require('../../../../../@zag-js_dom-query@1.29.1/node_modules/@zag-js/dom-query/dist/index.cjs');
+const index$2 = require('../../../../../@zag-js_utils@1.29.1/node_modules/@zag-js/utils/dist/index.cjs');
+const index = require('../../../../../@zag-js_core@1.29.1/node_modules/@zag-js/core/dist/index.cjs');
+const index$4 = require('../../../../../@zag-js_types@1.29.1/node_modules/@zag-js/types/dist/index.cjs');
+
+// src/pin-input.anatomy.ts
+var anatomy = index$3.createAnatomy("pinInput").parts("root", "label", "input", "control");
+var parts = anatomy.build();
+var getRootId = (ctx) => ctx.ids?.root ?? `pin-input:${ctx.id}`;
+var getInputId = (ctx, id) => ctx.ids?.input?.(id) ?? `pin-input:${ctx.id}:${id}`;
+var getHiddenInputId = (ctx) => ctx.ids?.hiddenInput ?? `pin-input:${ctx.id}:hidden`;
+var getLabelId = (ctx) => ctx.ids?.label ?? `pin-input:${ctx.id}:label`;
+var getControlId = (ctx) => ctx.ids?.control ?? `pin-input:${ctx.id}:control`;
+var getRootEl = (ctx) => ctx.getById(getRootId(ctx));
+var getInputEls = (ctx) => {
+  const ownerId = CSS.escape(getRootId(ctx));
+  const selector = `input[data-ownedby=${ownerId}]`;
+  return index$1.queryAll(getRootEl(ctx), selector);
+};
+var getInputElAtIndex = (ctx, index) => getInputEls(ctx)[index];
+var getFirstInputEl = (ctx) => getInputEls(ctx)[0];
+var getHiddenInputEl = (ctx) => ctx.getById(getHiddenInputId(ctx));
+var setInputValue = (inputEl, value) => {
+  inputEl.value = value;
+  inputEl.setAttribute("value", value);
+};
+
+// src/pin-input.utils.ts
+var REGEX = {
+  numeric: /^[0-9]+$/,
+  alphabetic: /^[A-Za-z]+$/,
+  alphanumeric: /^[a-zA-Z0-9]+$/i
+};
+function isValidType(type, value) {
+  if (!type) return true;
+  return !!REGEX[type]?.test(value);
+}
+function isValidValue(value, type, pattern) {
+  if (!pattern) return isValidType(type, value);
+  const regex = new RegExp(pattern, "g");
+  return regex.test(value);
+}
+
+// src/pin-input.connect.ts
+function connect(service, normalize) {
+  const { send, context, computed, prop, scope } = service;
+  const complete = computed("isValueComplete");
+  const disabled = !!prop("disabled");
+  const readOnly = !!prop("readOnly");
+  const invalid = !!prop("invalid");
+  const required = !!prop("required");
+  const translations = prop("translations");
+  const focusedIndex = context.get("focusedIndex");
+  function focus() {
+    getFirstInputEl(scope)?.focus();
+  }
+  return {
+    focus,
+    count: context.get("count"),
+    items: Array.from({ length: context.get("count") }).map((_, i) => i),
+    value: context.get("value"),
+    valueAsString: computed("valueAsString"),
+    complete,
+    setValue(value) {
+      if (!Array.isArray(value)) {
+        index$2.invariant("[pin-input/setValue] value must be an array");
+      }
+      send({ type: "VALUE.SET", value });
+    },
+    clearValue() {
+      send({ type: "VALUE.CLEAR" });
+    },
+    setValueAtIndex(index, value) {
+      send({ type: "VALUE.SET", value, index });
+    },
+    getRootProps() {
+      return normalize.element({
+        dir: prop("dir"),
+        ...parts.root.attrs,
+        id: getRootId(scope),
+        "data-invalid": index$1.dataAttr(invalid),
+        "data-disabled": index$1.dataAttr(disabled),
+        "data-complete": index$1.dataAttr(complete),
+        "data-readonly": index$1.dataAttr(readOnly)
+      });
+    },
+    getLabelProps() {
+      return normalize.label({
+        ...parts.label.attrs,
+        dir: prop("dir"),
+        htmlFor: getHiddenInputId(scope),
+        id: getLabelId(scope),
+        "data-invalid": index$1.dataAttr(invalid),
+        "data-disabled": index$1.dataAttr(disabled),
+        "data-complete": index$1.dataAttr(complete),
+        "data-required": index$1.dataAttr(required),
+        "data-readonly": index$1.dataAttr(readOnly),
+        onClick(event) {
+          event.preventDefault();
+          focus();
+        }
+      });
+    },
+    getHiddenInputProps() {
+      return normalize.input({
+        "aria-hidden": true,
+        type: "text",
+        tabIndex: -1,
+        id: getHiddenInputId(scope),
+        readOnly,
+        disabled,
+        required,
+        name: prop("name"),
+        form: prop("form"),
+        style: index$1.visuallyHiddenStyle,
+        maxLength: computed("valueLength"),
+        defaultValue: computed("valueAsString")
+      });
+    },
+    getControlProps() {
+      return normalize.element({
+        ...parts.control.attrs,
+        dir: prop("dir"),
+        id: getControlId(scope)
+      });
+    },
+    getInputProps(props2) {
+      const { index } = props2;
+      const inputType = prop("type") === "numeric" ? "tel" : "text";
+      return normalize.input({
+        ...parts.input.attrs,
+        dir: prop("dir"),
+        disabled,
+        "data-disabled": index$1.dataAttr(disabled),
+        "data-complete": index$1.dataAttr(complete),
+        id: getInputId(scope, index.toString()),
+        "data-index": index,
+        "data-ownedby": getRootId(scope),
+        "aria-label": translations?.inputLabel?.(index, computed("valueLength")),
+        inputMode: prop("otp") || prop("type") === "numeric" ? "numeric" : "text",
+        "aria-invalid": index$1.ariaAttr(invalid),
+        "data-invalid": index$1.dataAttr(invalid),
+        type: prop("mask") ? "password" : inputType,
+        defaultValue: context.get("value")[index] || "",
+        readOnly,
+        autoCapitalize: "none",
+        autoComplete: prop("otp") ? "one-time-code" : "off",
+        placeholder: focusedIndex === index ? "" : prop("placeholder"),
+        onBeforeInput(event) {
+          try {
+            const value = index$1.getBeforeInputValue(event);
+            const isValid = isValidValue(value, prop("type"), prop("pattern"));
+            if (!isValid) {
+              send({ type: "VALUE.INVALID", value });
+              event.preventDefault();
+            }
+            if (value.length > 2) {
+              event.currentTarget.setSelectionRange(0, 1, "forward");
+            }
+          } catch {
+          }
+        },
+        onChange(event) {
+          const evt = index$1.getNativeEvent(event);
+          const { value } = event.currentTarget;
+          if (evt.inputType === "insertFromPaste" || value.length > 2) {
+            send({ type: "INPUT.PASTE", value });
+            event.currentTarget.value = value[0];
+            event.preventDefault();
+            return;
+          }
+          if (evt.inputType === "deleteContentBackward") {
+            send({ type: "INPUT.BACKSPACE" });
+            return;
+          }
+          send({ type: "INPUT.CHANGE", value, index });
+        },
+        onKeyDown(event) {
+          if (event.defaultPrevented) return;
+          if (index$1.isComposingEvent(event)) return;
+          if (index$1.isModifierKey(event)) return;
+          const keyMap = {
+            Backspace() {
+              send({ type: "INPUT.BACKSPACE" });
+            },
+            Delete() {
+              send({ type: "INPUT.DELETE" });
+            },
+            ArrowLeft() {
+              send({ type: "INPUT.ARROW_LEFT" });
+            },
+            ArrowRight() {
+              send({ type: "INPUT.ARROW_RIGHT" });
+            },
+            Enter() {
+              send({ type: "INPUT.ENTER" });
+            }
+          };
+          const exec = keyMap[index$1.getEventKey(event, {
+            dir: prop("dir"),
+            orientation: "horizontal"
+          })];
+          if (exec) {
+            exec(event);
+            event.preventDefault();
+          }
+        },
+        onFocus() {
+          send({ type: "INPUT.FOCUS", index });
+        },
+        onBlur(event) {
+          const target = event.relatedTarget;
+          if (index$1.isHTMLElement(target) && target.dataset.ownedby === getRootId(scope)) return;
+          send({ type: "INPUT.BLUR", index });
+        }
+      });
+    }
+  };
+}
+var { choose, createMachine } = index.setup();
+var machine = createMachine({
+  props({ props: props2 }) {
+    return {
+      placeholder: "\u25CB",
+      otp: false,
+      type: "numeric",
+      defaultValue: props2.count ? fill([], props2.count) : [],
+      ...props2,
+      translations: {
+        inputLabel: (index, length) => `pin code ${index + 1} of ${length}`,
+        ...props2.translations
+      }
+    };
+  },
+  initialState() {
+    return "idle";
+  },
+  context({ prop, bindable }) {
+    return {
+      value: bindable(() => ({
+        value: prop("value"),
+        defaultValue: prop("defaultValue"),
+        isEqual: index$2.isEqual,
+        onChange(value) {
+          prop("onValueChange")?.({ value, valueAsString: value.join("") });
+        }
+      })),
+      focusedIndex: bindable(() => ({
+        sync: true,
+        defaultValue: -1
+      })),
+      // TODO: Move this to `props` in next major version
+      count: bindable(() => ({
+        defaultValue: prop("count")
+      }))
+    };
+  },
+  computed: {
+    _value: ({ context }) => fill(context.get("value"), context.get("count")),
+    valueLength: ({ computed }) => computed("_value").length,
+    filledValueLength: ({ computed }) => computed("_value").filter((v) => v?.trim() !== "").length,
+    isValueComplete: ({ computed }) => computed("valueLength") === computed("filledValueLength"),
+    valueAsString: ({ computed }) => computed("_value").join(""),
+    focusedValue: ({ computed, context }) => computed("_value")[context.get("focusedIndex")] || ""
+  },
+  entry: choose([
+    {
+      guard: "autoFocus",
+      actions: ["setInputCount", "setFocusIndexToFirst"]
+    },
+    { actions: ["setInputCount"] }
+  ]),
+  watch({ action, track, context, computed }) {
+    track([() => context.get("focusedIndex")], () => {
+      action(["focusInput", "selectInputIfNeeded"]);
+    });
+    track([() => context.get("value").join(",")], () => {
+      action(["syncInputElements", "dispatchInputEvent"]);
+    });
+    track([() => computed("isValueComplete")], () => {
+      action(["invokeOnComplete", "blurFocusedInputIfNeeded"]);
+    });
+  },
+  on: {
+    "VALUE.SET": [
+      {
+        guard: "hasIndex",
+        actions: ["setValueAtIndex"]
+      },
+      { actions: ["setValue"] }
+    ],
+    "VALUE.CLEAR": {
+      actions: ["clearValue", "setFocusIndexToFirst"]
+    }
+  },
+  states: {
+    idle: {
+      on: {
+        "INPUT.FOCUS": {
+          target: "focused",
+          actions: ["setFocusedIndex"]
+        }
+      }
+    },
+    focused: {
+      on: {
+        "INPUT.CHANGE": {
+          actions: ["setFocusedValue", "syncInputValue", "setNextFocusedIndex"]
+        },
+        "INPUT.PASTE": {
+          actions: ["setPastedValue", "setLastValueFocusIndex"]
+        },
+        "INPUT.FOCUS": {
+          actions: ["setFocusedIndex"]
+        },
+        "INPUT.BLUR": {
+          target: "idle",
+          actions: ["clearFocusedIndex"]
+        },
+        "INPUT.DELETE": {
+          guard: "hasValue",
+          actions: ["clearFocusedValue"]
+        },
+        "INPUT.ARROW_LEFT": {
+          actions: ["setPrevFocusedIndex"]
+        },
+        "INPUT.ARROW_RIGHT": {
+          actions: ["setNextFocusedIndex"]
+        },
+        "INPUT.BACKSPACE": [
+          {
+            guard: "hasValue",
+            actions: ["clearFocusedValue"]
+          },
+          {
+            actions: ["setPrevFocusedIndex", "clearFocusedValue"]
+          }
+        ],
+        "INPUT.ENTER": {
+          guard: "isValueComplete",
+          actions: ["requestFormSubmit"]
+        },
+        "VALUE.INVALID": {
+          actions: ["invokeOnInvalid"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      autoFocus: ({ prop }) => !!prop("autoFocus"),
+      hasValue: ({ context }) => context.get("value")[context.get("focusedIndex")] !== "",
+      isValueComplete: ({ computed }) => computed("isValueComplete"),
+      hasIndex: ({ event }) => event.index !== void 0
+    },
+    actions: {
+      dispatchInputEvent({ computed, scope }) {
+        const inputEl = getHiddenInputEl(scope);
+        index$1.dispatchInputValueEvent(inputEl, { value: computed("valueAsString") });
+      },
+      setInputCount({ scope, context, prop }) {
+        if (prop("count")) return;
+        const inputEls = getInputEls(scope);
+        context.set("count", inputEls.length);
+      },
+      focusInput({ context, scope }) {
+        const focusedIndex = context.get("focusedIndex");
+        if (focusedIndex === -1) return;
+        getInputElAtIndex(scope, focusedIndex)?.focus({ preventScroll: true });
+      },
+      selectInputIfNeeded({ context, prop, scope }) {
+        const focusedIndex = context.get("focusedIndex");
+        if (!prop("selectOnFocus") || focusedIndex === -1) return;
+        index$1.raf(() => {
+          getInputElAtIndex(scope, focusedIndex)?.select();
+        });
+      },
+      invokeOnComplete({ computed, prop }) {
+        if (!computed("isValueComplete")) return;
+        prop("onValueComplete")?.({
+          value: computed("_value"),
+          valueAsString: computed("valueAsString")
+        });
+      },
+      invokeOnInvalid({ context, event, prop }) {
+        prop("onValueInvalid")?.({
+          value: event.value,
+          index: context.get("focusedIndex")
+        });
+      },
+      clearFocusedIndex({ context }) {
+        context.set("focusedIndex", -1);
+      },
+      setFocusedIndex({ context, event }) {
+        context.set("focusedIndex", event.index);
+      },
+      setValue({ context, event }) {
+        const value = fill(event.value, context.get("count"));
+        context.set("value", value);
+      },
+      setFocusedValue({ context, event, computed, flush }) {
+        const focusedValue = computed("focusedValue");
+        const focusedIndex = context.get("focusedIndex");
+        const value = getNextValue(focusedValue, event.value);
+        flush(() => {
+          context.set("value", index$2.setValueAtIndex(computed("_value"), focusedIndex, value));
+        });
+      },
+      revertInputValue({ context, computed, scope }) {
+        const inputEl = getInputElAtIndex(scope, context.get("focusedIndex"));
+        setInputValue(inputEl, computed("focusedValue"));
+      },
+      syncInputValue({ context, event, scope }) {
+        const value = context.get("value");
+        const inputEl = getInputElAtIndex(scope, event.index);
+        setInputValue(inputEl, value[event.index]);
+      },
+      syncInputElements({ context, scope }) {
+        const inputEls = getInputEls(scope);
+        const value = context.get("value");
+        inputEls.forEach((inputEl, index) => {
+          setInputValue(inputEl, value[index]);
+        });
+      },
+      setPastedValue({ context, event, computed, flush }) {
+        index$1.raf(() => {
+          const valueAsString = computed("valueAsString");
+          const focusedIndex = context.get("focusedIndex");
+          const valueLength = computed("valueLength");
+          const filledValueLength = computed("filledValueLength");
+          const startIndex = Math.min(focusedIndex, filledValueLength);
+          const left = startIndex > 0 ? valueAsString.substring(0, focusedIndex) : "";
+          const right = event.value.substring(0, valueLength - startIndex);
+          const value = fill(`${left}${right}`.split(""), valueLength);
+          flush(() => {
+            context.set("value", value);
+          });
+        });
+      },
+      setValueAtIndex({ context, event, computed }) {
+        const nextValue = getNextValue(computed("focusedValue"), event.value);
+        context.set("value", index$2.setValueAtIndex(computed("_value"), event.index, nextValue));
+      },
+      clearValue({ context }) {
+        const nextValue = Array.from({ length: context.get("count") }).fill("");
+        queueMicrotask(() => {
+          context.set("value", nextValue);
+        });
+      },
+      clearFocusedValue({ context, computed }) {
+        const focusedIndex = context.get("focusedIndex");
+        if (focusedIndex === -1) return;
+        context.set("value", index$2.setValueAtIndex(computed("_value"), focusedIndex, ""));
+      },
+      setFocusIndexToFirst({ context }) {
+        context.set("focusedIndex", 0);
+      },
+      setNextFocusedIndex({ context, computed }) {
+        context.set("focusedIndex", Math.min(context.get("focusedIndex") + 1, computed("valueLength") - 1));
+      },
+      setPrevFocusedIndex({ context }) {
+        context.set("focusedIndex", Math.max(context.get("focusedIndex") - 1, 0));
+      },
+      setLastValueFocusIndex({ context, computed }) {
+        index$1.raf(() => {
+          context.set("focusedIndex", Math.min(computed("filledValueLength"), computed("valueLength") - 1));
+        });
+      },
+      blurFocusedInputIfNeeded({ context, prop, scope }) {
+        if (!prop("blurOnComplete")) return;
+        index$1.raf(() => {
+          getInputElAtIndex(scope, context.get("focusedIndex"))?.blur();
+        });
+      },
+      requestFormSubmit({ computed, prop, scope }) {
+        if (!prop("name") || !computed("isValueComplete")) return;
+        const inputEl = getHiddenInputEl(scope);
+        inputEl?.form?.requestSubmit();
+      }
+    }
+  }
+});
+function getNextValue(current, next) {
+  let nextValue = next;
+  if (current[0] === next[0]) {
+    nextValue = next[1];
+  } else if (current[0] === next[1]) {
+    nextValue = next[0];
+  }
+  const chars = nextValue.split("");
+  nextValue = chars[chars.length - 1];
+  return nextValue ?? "";
+}
+function fill(value, count) {
+  return Array.from({ length: count }).fill("").map((v, i) => value[i] || v);
+}
+index$4.createProps()([
+  "autoFocus",
+  "blurOnComplete",
+  "count",
+  "defaultValue",
+  "dir",
+  "disabled",
+  "form",
+  "getRootNode",
+  "id",
+  "ids",
+  "invalid",
+  "mask",
+  "name",
+  "onValueChange",
+  "onValueComplete",
+  "onValueInvalid",
+  "otp",
+  "pattern",
+  "placeholder",
+  "readOnly",
+  "required",
+  "selectOnFocus",
+  "translations",
+  "type",
+  "value"
+]);
+
+exports.anatomy = anatomy;
+exports.connect = connect;
+exports.machine = machine;