@ariakit/core 0.0.1 → 0.1.0

package/cjs/combobox/combobox-store.d.ts

@@ -0,0 +1,67 @@
+import type { CompositeStoreFunctions, CompositeStoreItem, CompositeStoreOptions, CompositeStoreState } from "../composite/composite-store.js";
+import type { MenuStore } from "../menu/menu-store.js";
+import type { PopoverStoreFunctions, PopoverStoreOptions, PopoverStoreState } from "../popover/popover-store.js";
+import type { SelectStore } from "../select/select-store.js";
+import type { Store, StoreOptions, StoreProps } from "../utils/store.js";
+import type { SetState } from "../utils/types.js";
+type Item = CompositeStoreItem & {
+    value?: string;
+};
+/**
+ * Creates a combobox store.
+ */
+export declare function createComboboxStore({ menu, select, ...props }?: ComboboxStoreProps): ComboboxStore;
+export type ComboboxStoreItem = Item;
+export interface ComboboxStoreState extends CompositeStoreState<Item>, PopoverStoreState {
+    /**
+     * @default true
+     */
+    includesBaseElement: boolean;
+    /**
+     * The input value.
+     */
+    value: string;
+    /**
+     * The value of the current active item.
+     */
+    activeValue: string | undefined;
+    /**
+     * Whether to reset the value when the combobox popover is hidden.
+     */
+    resetValueOnHide: boolean;
+}
+export interface ComboboxStoreFunctions extends CompositeStoreFunctions<Item>, PopoverStoreFunctions {
+    /**
+     * Sets the `value` state.
+     * @example
+     * store.setValue("Hello world");
+     * store.setValue((value) => value + "!");
+     */
+    setValue: SetState<ComboboxStoreState["value"]>;
+}
+export interface ComboboxStoreOptions extends StoreOptions<ComboboxStoreState, "includesBaseElement" | "value" | "resetValueOnHide">, CompositeStoreOptions<Item>, PopoverStoreOptions {
+    /**
+     * @default null
+     */
+    defaultActiveId?: CompositeStoreOptions<Item>["activeId"];
+    /**
+     * A reference to a menu store. This is used when combining the combobox with
+     * a menu (e.g., dropdown menu with a search input). The stores will share the
+     * same state.
+     */
+    menu?: MenuStore;
+    /**
+     * A reference to a select store. This is used when combining the combobox
+     * with a select (e.g., select with a search input). The stores will share the
+     * same state.
+     */
+    select?: SelectStore;
+    /**
+     * The combobox initial value.
+     * @default ""
+     */
+    defaultValue?: ComboboxStoreState["value"];
+}
+export type ComboboxStoreProps = ComboboxStoreOptions & StoreProps<ComboboxStoreState>;
+export type ComboboxStore = ComboboxStoreFunctions & Store<ComboboxStoreState>;
+export {};

package/cjs/composite/composite-overflow-store.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _3KP2MDG6cjs = require('../__chunks/3KP2MDG6.cjs');
+require('../__chunks/EFEGT32M.cjs');
+require('../__chunks/7ZXWQTAY.cjs');
+require('../__chunks/3BBA3Z5G.cjs');
+require('../__chunks/5D5Y5EI4.cjs');
+
+// src/composite/composite-overflow-store.ts
+function createCompositeOverflowStore(props = {}) {
+  return _3KP2MDG6cjs.createPopoverStore.call(void 0, props);
+}
+
+
+exports.createCompositeOverflowStore = createCompositeOverflowStore;

package/cjs/composite/composite-overflow-store.d.ts

@@ -0,0 +1,10 @@
+import type { PopoverStore, PopoverStoreFunctions, PopoverStoreOptions, PopoverStoreProps, PopoverStoreState } from "../popover/popover-store.js";
+/**
+ * Creates a composite overflow store.
+ */
+export declare function createCompositeOverflowStore(props?: CompositeOverflowStoreProps): CompositeOverflowStore;
+export type CompositeOverflowStoreState = PopoverStoreState;
+export type CompositeOverflowStoreFunctions = PopoverStoreFunctions;
+export type CompositeOverflowStoreOptions = PopoverStoreOptions;
+export type CompositeOverflowStoreProps = PopoverStoreProps;
+export type CompositeOverflowStore = PopoverStore;

package/cjs/composite/composite-store.cjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _AZVDLKO3cjs = require('../__chunks/AZVDLKO3.cjs');
+require('../__chunks/NX5OHIMM.cjs');
+require('../__chunks/3BBA3Z5G.cjs');
+require('../__chunks/5D5Y5EI4.cjs');
+require('../__chunks/OFNGELMA.cjs');
+require('../__chunks/GDZQUFNP.cjs');
+
+
+exports.createCompositeStore = _AZVDLKO3cjs.createCompositeStore;

package/cjs/composite/composite-store.d.ts

@@ -0,0 +1,202 @@
+import type { CollectionStoreFunctions, CollectionStoreItem, CollectionStoreOptions, CollectionStoreState } from "../collection/collection-store.js";
+import type { Store, StoreOptions, StoreProps } from "../utils/store.js";
+import type { SetState } from "../utils/types.js";
+type Orientation = "horizontal" | "vertical" | "both";
+type Item = CollectionStoreItem & {
+    rowId?: string;
+    disabled?: boolean;
+    children?: string;
+};
+/**
+ * Creates a composite store.
+ */
+export declare function createCompositeStore<T extends Item = Item>(props?: CompositeStoreProps<T>): CompositeStore<T>;
+export type CompositeStoreOrientation = Orientation;
+export type CompositeStoreItem = Item;
+export interface CompositeStoreState<T extends Item = Item> extends CollectionStoreState<T> {
+    /**
+     * The composite element.
+     */
+    baseElement: HTMLElement | null;
+    /**
+     * If enabled, the composite element will act as an
+     * [aria-activedescendant](https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/#kbd_focus_activedescendant)
+     * container instead of [roving
+     * tabindex](https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/#kbd_roving_tabindex).
+     * DOM focus will remain on the composite element while its items receive
+     * virtual focus.
+     * @default false
+     */
+    virtualFocus: boolean;
+    /**
+     * Defines the orientation of the composite widget. If the composite has a
+     * single row or column (one-dimensional), the `orientation` value determines
+     * which arrow keys can be used to move focus:
+     *   - `both`: all arrow keys work.
+     *   - `horizontal`: only left and right arrow keys work.
+     *   - `vertical`: only up and down arrow keys work.
+     *
+     * It doesn't have any effect on two-dimensional composites.
+     * @default "both"
+     */
+    orientation: Orientation;
+    /**
+     * Determines how the `next` and `previous` functions will behave. If `rtl` is
+     * set to `true`, they will be inverted. This only affects the composite
+     * widget behavior. You still need to set `dir="rtl"` on HTML/CSS.
+     * @default false
+     */
+    rtl: boolean;
+    /**
+     * Determines how the focus behaves when the user reaches the end of the
+     * composite widget.
+     *
+     * On one-dimensional composites:
+     *   - `true` loops from the last item to the first item and vice-versa.
+     *   - `horizontal` loops only if `orientation` is `horizontal` or not set.
+     *   - `vertical` loops only if `orientation` is `vertical` or not set.
+     *   - If `includesBaseElement` is set to `true` (or `activeId` is initially
+     *     set to `null`), the composite element will be focused in between the
+     *     last and first items.
+     *
+     * On two-dimensional composites (when using `CompositeRow`):
+     *   - `true` loops from the last row/column item to the first item in the
+     *     same row/column and vice-versa. If it's the last item in the last row,
+     *     it moves to the first item in the first row and vice-versa.
+     *   - `horizontal` loops only from the last row item to the first item in the
+     *     same row.
+     *   - `vertical` loops only from the last column item to the first item in
+     *     the column row.
+     *   - If `includesBaseElement` is set to `true` (or `activeId` is initially
+     *     set to `null`), vertical loop will have no effect as moving down from
+     *     the last row or up from the first row will focus the composite element.
+     *   - If `focusWrap` matches the value of `focusLoop`, it'll wrap between the
+     *     last item in the last row or column and the first item in the first row
+     *     or column and vice-versa.
+     * @default false
+     */
+    focusLoop: boolean | Orientation;
+    /**
+     * **Works only on two-dimensional composites**. If enabled, moving to the
+     * next item from the last one in a row or column will focus the first item in
+     * the next row or column and vice-versa.
+     *   - `true` wraps between rows and columns.
+     *   - `horizontal` wraps only between rows.
+     *   - `vertical` wraps only between columns.
+     *   - If `focusLoop` matches the value of `focusWrap`, it'll wrap between the
+     *     last item in the last row or column and the first item in the first row
+     *     or column and vice-versa.
+     * @default false
+     */
+    focusWrap: boolean | Orientation;
+    /**
+     * **Works only on two-dimensional composites**. If enabled, moving up or down
+     * when there's no next item or when the next item is disabled will shift to
+     * the item right before it.
+     * @default false
+     */
+    focusShift: boolean;
+    /**
+     * The number of times the `move` function has been called.
+     */
+    moves: number;
+    /**
+     * Indicates whether the composite element should be included in the focus
+     * order.
+     * @default false
+     */
+    includesBaseElement: boolean;
+    /**
+     * The current focused item `id`.
+     *   - `null` focuses the base composite element and users will be able to
+     *     navigate out of it using arrow keys.
+     *   - If `activeId` is initially set to `null`, the `includesBaseElement`
+     *     prop will also default to `true`, which means the base composite
+     *     element itself will have focus and users will be able to navigate to it
+     *     using arrow keys.
+     */
+    activeId: string | null | undefined;
+}
+export interface CompositeStoreFunctions<T extends Item = Item> extends CollectionStoreFunctions<T> {
+    /**
+     * Sets the `baseElement`.
+     */
+    setBaseElement: SetState<CompositeStoreState<T>["baseElement"]>;
+    /**
+     * Sets the `activeId` state without moving focus. If you want to move focus,
+     * use the `move` function instead.
+     * @example
+     * // Sets the composite element as the active item
+     * store.setActiveId(null);
+     * // Sets the item with id "item-1" as the active item
+     * store.setActiveId("item-1");
+     * // Sets the next item as the active item
+     * store.setActiveId(store.next());
+     */
+    setActiveId: SetState<CompositeStoreState<T>["activeId"]>;
+    /**
+     * Moves focus to a given item id and sets it as the active item. Passing
+     * `null` will focus the composite element itself.
+     * @param id The item id to move focus to.
+     * @example
+     * // Moves focus to the composite element
+     * store.move(null);
+     * // Moves focus to the item with id "item-1"
+     * store.move("item-1");
+     * // Moves focus to the next item
+     * store.move(store.next());
+     */
+    move: (id?: string | null) => void;
+    /**
+     * Returns the id of the next item based on the current `activeId` state.
+     * @param skip The number of items to skip. Defaults to 1.
+     * @example
+     * const nextId = store.next();
+     * const nextNextId = store.next(2);
+     */
+    next: (skip?: number) => string | null | undefined;
+    /**
+     * Returns the id of the previous item based on the current `activeId` state.
+     * @param skip The number of items to skip. Defaults to 1.
+     * @example
+     * const previousId = store.previous();
+     * const previousPreviousId = store.previous(2);
+     */
+    previous: (skip?: number) => string | null | undefined;
+    /**
+     * Returns the id of the item above based on the current `activeId` state.
+     * @param skip The number of items to skip. Defaults to 1.
+     * @example
+     * const upId = store.up();
+     * const upUpId = store.up(2);
+     */
+    up: (skip?: number) => string | null | undefined;
+    /**
+     * Returns the id of the item below based on the current `activeId` state.
+     * @param skip The number of items to skip. Defaults to 1.
+     * @example
+     * const downId = store.down();
+     * const downDownId = store.down(2);
+     */
+    down: (skip?: number) => string | null | undefined;
+    /**
+     * Returns the id of the first item.
+     */
+    first: () => string | null | undefined;
+    /**
+     * Returns the id of the last item.
+     */
+    last: () => string | null | undefined;
+}
+export interface CompositeStoreOptions<T extends Item = Item> extends StoreOptions<CompositeStoreState<T>, "virtualFocus" | "orientation" | "rtl" | "focusLoop" | "focusWrap" | "focusShift" | "includesBaseElement" | "activeId">, CollectionStoreOptions<T> {
+    /**
+     * The composite item id that should be active by default when the composite
+     * widget is rendered. If `null`, the composite element itself will have focus
+     * and users will be able to navigate to it using arrow keys. If `undefined`,
+     * the first enabled item will be focused.
+     */
+    defaultActiveId?: CompositeStoreState<T>["activeId"];
+}
+export type CompositeStoreProps<T extends Item = Item> = CompositeStoreOptions<T> & StoreProps<CompositeStoreState<T>>;
+export type CompositeStore<T extends Item = Item> = CompositeStoreFunctions<T> & Store<CompositeStoreState<T>>;
+export {};

package/cjs/dialog/dialog-store.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _EFEGT32Mcjs = require('../__chunks/EFEGT32M.cjs');
+require('../__chunks/7ZXWQTAY.cjs');
+require('../__chunks/3BBA3Z5G.cjs');
+require('../__chunks/5D5Y5EI4.cjs');
+
+
+exports.createDialogStore = _EFEGT32Mcjs.createDialogStore;

package/cjs/dialog/dialog-store.d.ts

@@ -0,0 +1,10 @@
+import type { DisclosureStore, DisclosureStoreFunctions, DisclosureStoreOptions, DisclosureStoreProps, DisclosureStoreState } from "../disclosure/disclosure-store.js";
+/**
+ * Creates a dialog store.
+ */
+export declare function createDialogStore(props?: DialogStoreProps): DialogStore;
+export type DialogStoreState = DisclosureStoreState;
+export type DialogStoreFunctions = DisclosureStoreFunctions;
+export type DialogStoreOptions = DisclosureStoreOptions;
+export type DialogStoreProps = DisclosureStoreProps;
+export type DialogStore = DisclosureStore;

package/cjs/disclosure/disclosure-store.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _7ZXWQTAYcjs = require('../__chunks/7ZXWQTAY.cjs');
+require('../__chunks/3BBA3Z5G.cjs');
+require('../__chunks/5D5Y5EI4.cjs');
+
+
+exports.createDisclosureStore = _7ZXWQTAYcjs.createDisclosureStore;

package/cjs/disclosure/disclosure-store.d.ts

@@ -0,0 +1,87 @@
+import type { Store, StoreOptions, StoreProps } from "../utils/store.js";
+import type { SetState } from "../utils/types.js";
+/**
+ * Creates a disclosure store.
+ */
+export declare function createDisclosureStore(props?: DisclosureStoreProps): DisclosureStore;
+export interface DisclosureStoreState {
+    /**
+     * The visibility state of the content.
+     * @default false
+     */
+    open: boolean;
+    /**
+     * The mounted state of the content. If `animated` is `false` or not defined,
+     * this will be the same as `open`. Otherwise, it will wait for the animation
+     * to complete before becoming `false` so the content is not unmounted while
+     * animating.
+     */
+    mounted: boolean;
+    /**
+     * Determines whether the content should animate when it is shown or hidden.
+     *   - If `true`, the `animating` state will be `true` when the content is
+     *     shown or hidden and it will wait for `stopAnimation` to be called or a
+     *     CSS animation/transition to end before becoming `false`.
+     *   - If it's set to a number, the `animating` state will be `true` when the
+     *     content is shown or hidden and it will wait for the number of
+     *     milliseconds to pass before becoming `false`.
+     * @default false
+     */
+    animated: boolean | number;
+    /**
+     * Whether the content is currently animating.
+     */
+    animating: boolean;
+    /**
+     * The content element that is being shown or hidden.
+     */
+    contentElement: HTMLElement | null;
+    /**
+     * The disclosure button element that toggles the content.
+     */
+    disclosureElement: HTMLElement | null;
+}
+export interface DisclosureStoreFunctions {
+    /**
+     * Sets the `open` state.
+     * @example
+     * store.setOpen(true);
+     * store.setOpen((open) => !open);
+     */
+    setOpen: SetState<DisclosureStoreState["open"]>;
+    /**
+     * Sets the `open` state to `true`.
+     */
+    show: () => void;
+    /**
+     * Sets the `open` state to `false`.
+     */
+    hide: () => void;
+    /**
+     * Toggles the `open` state.
+     */
+    toggle: () => void;
+    /**
+     * Sets the `animating` state to `false`, which will automatically set the
+     * `mounted` state to `false` if it was `true`. This means that the content
+     * element can be safely unmounted.
+     */
+    stopAnimation: () => void;
+    /**
+     * Sets the `contentElement` state.
+     */
+    setContentElement: SetState<DisclosureStoreState["contentElement"]>;
+    /**
+     * Sets the `disclosureElement` state.
+     */
+    setDisclosureElement: SetState<DisclosureStoreState["disclosureElement"]>;
+}
+export interface DisclosureStoreOptions extends StoreOptions<DisclosureStoreState, "open" | "animated"> {
+    /**
+     * The default visibility state of the content.
+     * @default false
+     */
+    defaultOpen?: DisclosureStoreState["open"];
+}
+export type DisclosureStoreProps = DisclosureStoreOptions & StoreProps<DisclosureStoreState>;
+export type DisclosureStore = DisclosureStoreFunctions & Store<DisclosureStoreState>;

package/cjs/form/form-store.cjs

@@ -0,0 +1,241 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _NX5OHIMMcjs = require('../__chunks/NX5OHIMM.cjs');
+
+
+var _3BBA3Z5Gcjs = require('../__chunks/3BBA3Z5G.cjs');
+
+
+
+
+
+var _5D5Y5EI4cjs = require('../__chunks/5D5Y5EI4.cjs');
+require('../__chunks/OFNGELMA.cjs');
+
+// src/form/form-store.ts
+function nextFrame() {
+  return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+}
+function hasMessages(object) {
+  return Object.keys(object).some((key) => {
+    if (_5D5Y5EI4cjs.isObject.call(void 0, object[key])) {
+      return hasMessages(object[key]);
+    }
+    return !!object[key];
+  });
+}
+function get(values, path, defaultValue2) {
+  const [key, ...rest] = Array.isArray(path) ? path : `${path}`.split(".");
+  if (key == null || !values) {
+    return defaultValue2;
+  }
+  if (!rest.length) {
+    return _nullishCoalesce(values[key], () => ( defaultValue2));
+  }
+  return get(values[key], rest, defaultValue2);
+}
+function set(values, path, value) {
+  const [k, ...rest] = Array.isArray(path) ? path : `${path}`.split(".");
+  if (k == null)
+    return values;
+  const key = k;
+  const isIntegerKey = _5D5Y5EI4cjs.isInteger.call(void 0, key);
+  const nextValues = isIntegerKey ? values || [] : values || {};
+  const nestedValues = nextValues[key];
+  const result = rest.length && (Array.isArray(nestedValues) || _5D5Y5EI4cjs.isObject.call(void 0, nestedValues)) ? set(nestedValues, rest, value) : value;
+  if (isIntegerKey) {
+    const index = Number(key);
+    if (values) {
+      return [
+        ...values.slice(0, index),
+        result,
+        ...values.slice(index + 1)
+      ];
+    }
+    const nextValues2 = [];
+    nextValues2[index] = result;
+    return nextValues2;
+  }
+  return { ...values, [key]: result };
+}
+function setAll(values, value) {
+  const result = {};
+  const keys = Object.keys(values);
+  for (const key of keys) {
+    const currentValue = values[key];
+    if (Array.isArray(currentValue)) {
+      result[key] = currentValue.map((v) => {
+        if (_5D5Y5EI4cjs.isObject.call(void 0, v)) {
+          return setAll(v, value);
+        }
+        return value;
+      });
+    } else if (_5D5Y5EI4cjs.isObject.call(void 0, currentValue)) {
+      result[key] = setAll(currentValue, value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function getNameHandler(cache, prevKeys = []) {
+  const handler = {
+    get(target, key) {
+      if (["toString", "valueOf", Symbol.toPrimitive].includes(key)) {
+        return () => prevKeys.join(".");
+      }
+      const nextKeys = [...prevKeys, key];
+      const nextKey = nextKeys.join(".");
+      if (cache[nextKey]) {
+        return cache[nextKey];
+      }
+      const nextProxy = new Proxy(target, getNameHandler(cache, nextKeys));
+      cache[nextKey] = nextProxy;
+      return nextProxy;
+    }
+  };
+  return handler;
+}
+function createNames() {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return new Proxy(/* @__PURE__ */ Object.create(null), getNameHandler(cache));
+}
+function createFormStore(props = {}) {
+  const syncState = _optionalChain([props, 'access', _ => _.store, 'optionalAccess', _2 => _2.getState, 'call', _3 => _3()]);
+  const collection = _NX5OHIMMcjs.createCollectionStore.call(void 0, props);
+  const values = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.values,
+    _optionalChain([syncState, 'optionalAccess', _4 => _4.values]),
+    props.defaultValues,
+    {}
+  );
+  const errors = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.errors,
+    _optionalChain([syncState, 'optionalAccess', _5 => _5.errors]),
+    props.defaultErrors,
+    {}
+  );
+  const touched = _5D5Y5EI4cjs.defaultValue.call(void 0, 
+    props.touched,
+    _optionalChain([syncState, 'optionalAccess', _6 => _6.touched]),
+    props.defaultTouched,
+    {}
+  );
+  const initialState = {
+    ...collection.getState(),
+    values,
+    errors,
+    touched,
+    validating: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _7 => _7.validating]), false),
+    submitting: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _8 => _8.submitting]), false),
+    submitSucceed: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _9 => _9.submitSucceed]), 0),
+    submitFailed: _5D5Y5EI4cjs.defaultValue.call(void 0, _optionalChain([syncState, 'optionalAccess', _10 => _10.submitFailed]), 0),
+    valid: !hasMessages(errors)
+  };
+  const form = _3BBA3Z5Gcjs.createStore.call(void 0, initialState, collection, props.store);
+  const validateCallbacks = /* @__PURE__ */ new Set();
+  const submitCallbacks = /* @__PURE__ */ new Set();
+  const validate = async () => {
+    form.setState("validating", true);
+    form.setState("errors", {});
+    try {
+      const callbacks = [...validateCallbacks];
+      const results = callbacks.map((callback) => callback(form.getState()));
+      await Promise.all(results).then(nextFrame);
+      return !hasMessages(form.getState().errors);
+    } finally {
+      form.setState("validating", false);
+    }
+  };
+  return {
+    ...collection,
+    ...form,
+    names: createNames(),
+    setValues: (values2) => form.setState("values", values2),
+    getValue: (name) => get(form.getState().values, name),
+    setValue: (name, value) => form.setState("values", (values2) => {
+      const prevValue = get(values2, name);
+      const nextValue = _5D5Y5EI4cjs.applyState.call(void 0, value, prevValue);
+      if (nextValue === prevValue)
+        return values2;
+      return set(values2, name, nextValue);
+    }),
+    pushValue: (name, value) => form.setState("values", (values2) => {
+      const array = get(values2, name, []);
+      return set(values2, name, [...array, value]);
+    }),
+    removeValue: (name, index) => form.setState("values", (values2) => {
+      const array = get(values2, name, []);
+      return set(values2, name, [
+        ...array.slice(0, index),
+        null,
+        ...array.slice(index + 1)
+      ]);
+    }),
+    setErrors: (errors2) => form.setState("errors", errors2),
+    getError: (name) => get(form.getState().errors, name),
+    setError: (name, error) => form.setState("errors", (errors2) => {
+      const prevError = get(errors2, name);
+      const nextError = _5D5Y5EI4cjs.applyState.call(void 0, error, prevError);
+      if (nextError === prevError)
+        return errors2;
+      return set(errors2, name, nextError);
+    }),
+    setTouched: (touched2) => form.setState("touched", touched2),
+    getFieldTouched: (name) => !!get(form.getState().touched, name),
+    setFieldTouched: (name, value) => form.setState("touched", (touched2) => {
+      const prevValue = get(touched2, name);
+      const nextValue = _5D5Y5EI4cjs.applyState.call(void 0, value, prevValue);
+      if (nextValue === prevValue)
+        return touched2;
+      return set(touched2, name, nextValue);
+    }),
+    onValidate: (callback) => {
+      validateCallbacks.add(callback);
+      return () => validateCallbacks.delete(callback);
+    },
+    validate,
+    onSubmit: (callback) => {
+      submitCallbacks.add(callback);
+      return () => submitCallbacks.delete(callback);
+    },
+    submit: async () => {
+      form.setState("submitting", true);
+      form.setState("touched", setAll(form.getState().values, true));
+      try {
+        if (await validate()) {
+          const callbacks = [...submitCallbacks];
+          const results = callbacks.map(
+            (callback) => callback(form.getState())
+          );
+          await Promise.all(results).then(nextFrame);
+          if (!hasMessages(form.getState().errors)) {
+            form.setState("submitSucceed", (count) => count + 1);
+            return true;
+          }
+        }
+        form.setState("submitFailed", (count) => count + 1);
+        return false;
+      } catch (error) {
+        form.setState("submitFailed", (count) => count + 1);
+        throw error;
+      } finally {
+        form.setState("submitting", false);
+      }
+    },
+    reset: () => {
+      form.setState("values", values);
+      form.setState("errors", errors);
+      form.setState("touched", touched);
+      form.setState("validating", false);
+      form.setState("submitting", false);
+      form.setState("submitSucceed", 0);
+      form.setState("submitFailed", 0);
+    }
+  };
+}
+
+
+
+
+exports.createFormStore = createFormStore; exports.get = get; exports.hasMessages = hasMessages;