kiru 0.44.4 → 0.45.1

package/dist/env.js

@@ -0,0 +1,6 @@
+const NODE_ENV = process.env.NODE_ENV;
+if (NODE_ENV !== "development" && NODE_ENV !== "production") {
+    throw new Error("NODE_ENV must either be set to development or production.");
+}
+export const __DEV__ = NODE_ENV === "development";
+//# sourceMappingURL=env.js.map

package/dist/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAA;AACrC,IAAI,QAAQ,KAAK,aAAa,IAAI,QAAQ,KAAK,YAAY,EAAE,CAAC;IAC5D,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAA;AAC9E,CAAC;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,KAAK,aAAa,CAAA"}

package/dist/error.d.ts

@@ -0,0 +1,19 @@
+import { $KIRU_ERROR } from "./constants.js";
+type KiruErrorOptions = string | {
+    message: string;
+    /** Used to indicate that the error is fatal and should crash the application */
+    fatal?: boolean;
+    /** Used to generate custom node stack */
+    vNode?: Kiru.VNode;
+};
+export declare class KiruError extends Error {
+    [$KIRU_ERROR]: boolean;
+    /** Indicates whether the error is fatal and should crash the application */
+    fatal?: boolean;
+    /** Present if vNode is provided */
+    customNodeStack?: string;
+    constructor(optionsOrMessage: KiruErrorOptions);
+    static isKiruError(error: unknown): error is KiruError;
+}
+export {};
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAI5C,KAAK,gBAAgB,GACjB,MAAM,GACN;IACE,OAAO,EAAE,MAAM,CAAA;IACf,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,yCAAyC;IACzC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,CAAA;CACnB,CAAA;AAEL,qBAAa,SAAU,SAAQ,KAAK;IAClC,CAAC,WAAW,CAAC,UAAO;IACpB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,mCAAmC;IACnC,eAAe,CAAC,EAAE,MAAM,CAAA;gBACZ,gBAAgB,EAAE,gBAAgB;IAgB9C,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS;CAGvD"}

package/dist/error.js

@@ -0,0 +1,63 @@
+var _a;
+import { $KIRU_ERROR } from "./constants.js";
+import { __DEV__ } from "./env.js";
+import { findParent, noop } from "./utils.js";
+export class KiruError extends Error {
+    constructor(optionsOrMessage) {
+        const message = typeof optionsOrMessage === "string"
+            ? optionsOrMessage
+            : optionsOrMessage.message;
+        super(message);
+        this[_a] = true;
+        if (typeof optionsOrMessage !== "string") {
+            if (__DEV__) {
+                if (optionsOrMessage?.vNode) {
+                    this.customNodeStack = captureErrorStack(optionsOrMessage.vNode);
+                }
+            }
+            this.fatal = optionsOrMessage?.fatal;
+        }
+    }
+    static isKiruError(error) {
+        return error instanceof Error && error[$KIRU_ERROR] === true;
+    }
+}
+_a = $KIRU_ERROR;
+function captureErrorStack(vNode) {
+    let n = vNode;
+    let componentFns = [];
+    while (n) {
+        if (!n.parent)
+            break; // skip root node
+        if (typeof n.type === "function") {
+            componentFns.push(getComponentErrorDisplayText(n.type));
+        }
+        else if (typeof n.type === "string") {
+            componentFns.push(n.type);
+        }
+        n = n.parent;
+    }
+    const componentNode = (typeof vNode.type === "function"
+        ? vNode
+        : findParent(vNode, (n) => typeof n.type === "function"));
+    return `The above error occurred in the <${getFunctionName(componentNode?.type || noop)}> component:
+
+${componentFns.map((x) => `   at ${x}`).join("\n")}\n`;
+}
+function getComponentErrorDisplayText(fn) {
+    let str = getFunctionName(fn);
+    if (__DEV__) {
+        const fileLink = getComponentFileLink(fn);
+        if (fileLink) {
+            str = `${str} (${fileLink})`;
+        }
+    }
+    return str;
+}
+function getFunctionName(fn) {
+    return fn.displayName ?? (fn.name || "Anonymous Function");
+}
+function getComponentFileLink(fn) {
+    return fn.toString().match(/\/\/ \[kiru_devtools\]:(.*)/)?.[1] ?? null;
+}
+//# sourceMappingURL=error.js.map

package/dist/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"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"}

package/dist/flags.d.ts

@@ -0,0 +1,6 @@
+export declare const flags: {
+    readonly set: (field: number, flag: number) => number;
+    readonly get: (field: number, n: number) => boolean;
+    readonly unsetRange: (field: number, start: number, end: number) => number;
+};
+//# sourceMappingURL=flags.d.ts.map

package/dist/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../src/flags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;0BAEL,MAAM,QAAQ,MAAM,KAAG,MAAM;0BAI7B,MAAM,KAAK,MAAM,KAAG,OAAO;iCAIpB,MAAM,SAAS,MAAM,OAAO,MAAM,KAAG,MAAM;CAIrD,CAAA"}

package/dist/flags.js

@@ -0,0 +1,16 @@
+export const flags = {
+    // Set the flag at position `n` (0-based index)
+    set(field, flag) {
+        return (field |= 1 << flag);
+    },
+    // Check if the flag at position `n` is set (true) or not (false)
+    get(field, n) {
+        return (field & (1 << n)) !== 0;
+    },
+    // Unset all flags between `start` and `end`
+    unsetRange(field, start, end) {
+        const mask = ((1 << (end - start + 1)) - 1) << start;
+        return field & ~mask;
+    },
+};
+//# sourceMappingURL=flags.js.map

package/dist/flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.js","sourceRoot":"","sources":["../src/flags.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,+CAA+C;IAC/C,GAAG,CAAC,KAAa,EAAE,IAAY;QAC7B,OAAO,CAAC,KAAK,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA;IAC7B,CAAC;IACD,iEAAiE;IACjE,GAAG,CAAC,KAAa,EAAE,CAAS;QAC1B,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;IACjC,CAAC;IACD,4CAA4C;IAC5C,UAAU,CAAC,KAAa,EAAE,KAAa,EAAE,GAAW;QAClD,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,CAAA;QACpD,OAAO,KAAK,GAAG,CAAC,IAAI,CAAA;IACtB,CAAC;CACO,CAAA"}

package/dist/form/index.d.ts

@@ -0,0 +1,4 @@
+import type { UseFormConfig, UseFormState } from "./types";
+export type * from "./types";
+export declare function useForm<T extends Record<string, unknown> = {}>(config: UseFormConfig<T>): UseFormState<T>;
+//# sourceMappingURL=index.d.ts.map

package/dist/form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/form/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAaV,aAAa,EAEb,YAAY,EACb,MAAM,SAAS,CAAA;AAEhB,mBAAmB,SAAS,CAAA;AAkf5B,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAC5D,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACvB,YAAY,CAAC,CAAC,CAAC,CAsIjB"}

package/dist/form/index.js

@@ -0,0 +1,509 @@
+import { __DEV__ } from "../env.js";
+import { Fragment } from "../element.js";
+import { generateRandomID } from "../generateId.js";
+import { safeStringify, shallowCompare } from "../utils.js";
+import { useEffect } from "../hooks/useEffect.js";
+import { useMemo } from "../hooks/useMemo.js";
+import { useRef } from "../hooks/useRef.js";
+import { useHook, useRequestUpdate } from "../hooks/utils.js";
+import { objGet, objSet } from "./utils.js";
+function createFormController(config) {
+    let isSubmitting = false;
+    const subscribers = new Set();
+    const state = structuredClone(config.initialValues ?? {});
+    const formFieldValidators = {};
+    const formFieldDependencies = {};
+    const formFieldsTouched = {};
+    const formFieldUpdaters = new Map();
+    const asyncFormFieldValidators = {};
+    const formFieldErrors = {};
+    const canSubmit = () => {
+        return isAnyFieldValidating() === false && getErrors().length === 0;
+    };
+    const getSelectorState = () => {
+        return {
+            values: state,
+            canSubmit: canSubmit(),
+            isSubmitting,
+        };
+    };
+    const updateSubscribers = () => {
+        const selectorState = getSelectorState();
+        for (const sub of subscribers) {
+            const { selector, selection, update } = sub;
+            const newSelection = selector(selectorState);
+            if (shallowCompare(selection, newSelection))
+                continue;
+            sub.selection = newSelection;
+            update();
+        }
+    };
+    const updateFieldComponents = (name) => {
+        if (!formFieldUpdaters.has(name))
+            return;
+        for (const update of formFieldUpdaters.get(name))
+            update();
+    };
+    const validateField = async (name, evt) => {
+        const fieldErrors = (formFieldErrors[name] ?? (formFieldErrors[name] = {}));
+        const asyncFieldValidatorStates = (asyncFormFieldValidators[name] ?? (asyncFormFieldValidators[name] = {}));
+        const fieldValidators = formFieldValidators[name] ?? {};
+        const validatorCtx = { value: getFieldValue(name) };
+        switch (evt) {
+            case "onMount": {
+                if (!fieldValidators.onMount)
+                    return;
+                fieldErrors.onMount = fieldValidators.onMount(validatorCtx);
+                updateSubscribers();
+                updateFieldComponents(name);
+                break;
+            }
+            case "onChange": {
+                if (fieldErrors.onMount)
+                    delete fieldErrors.onMount;
+                formFieldsTouched[name] = true;
+                if (!fieldValidators.onChange)
+                    return;
+                fieldErrors.onChange = fieldValidators.onChange(validatorCtx);
+                if (asyncFieldValidatorStates.onChangeAsync &&
+                    asyncFieldValidatorStates.onChangeAsync.timeout !== -1) {
+                    window.clearTimeout(asyncFieldValidatorStates.onChangeAsync.timeout);
+                    asyncFieldValidatorStates.onChangeAsync.abortController?.abort();
+                    asyncFieldValidatorStates.onChangeAsync = {
+                        epoch: asyncFieldValidatorStates.onChangeAsync.epoch,
+                        timeout: -1,
+                        abortController: null,
+                    };
+                    delete fieldErrors.onChangeAsync;
+                }
+                else if (fieldErrors.onChangeAsync) {
+                    delete fieldErrors.onChangeAsync;
+                }
+                updateSubscribers();
+                updateFieldComponents(name);
+                break;
+            }
+            case "onBlur": {
+                formFieldsTouched[name] = true;
+                if (!fieldValidators.onBlur)
+                    return;
+                fieldErrors.onBlur = fieldValidators.onBlur(validatorCtx);
+                updateSubscribers();
+                updateFieldComponents(name);
+                break;
+            }
+            case "onChangeAsync": {
+                if (fieldErrors.onChange || !fieldValidators.onChangeAsync)
+                    return;
+                window.clearTimeout(asyncFieldValidatorStates.onChangeAsync?.timeout);
+                const epoch = (asyncFieldValidatorStates.onChangeAsync?.epoch ?? 0) + 1;
+                const debounceMs = fieldValidators.onChangeAsyncDebounceMs ?? 0;
+                const abortController = new AbortController();
+                const asyncValidatorCtx = {
+                    ...validatorCtx,
+                    abortSignal: abortController.signal,
+                };
+                if (debounceMs <= 0) {
+                    fieldErrors.onChangeAsync = await fieldValidators.onChangeAsync(asyncValidatorCtx);
+                    updateSubscribers();
+                    updateFieldComponents(name);
+                    return;
+                }
+                asyncFieldValidatorStates.onChangeAsync = {
+                    abortController,
+                    timeout: window.setTimeout(() => {
+                        fieldValidators
+                            .onChangeAsync?.(asyncValidatorCtx)
+                            .then((result) => {
+                            if (fieldErrors.onChange)
+                                return;
+                            if (epoch !== asyncFieldValidatorStates.onChangeAsync?.epoch) {
+                                return;
+                            }
+                            fieldErrors.onChangeAsync = result;
+                            asyncFieldValidatorStates.onChangeAsync = {
+                                timeout: -1,
+                                epoch,
+                                abortController,
+                            };
+                            updateSubscribers();
+                            updateFieldComponents(name);
+                        });
+                    }, debounceMs),
+                    epoch,
+                };
+                updateSubscribers();
+                break;
+            }
+            case "onSubmit": {
+                fieldErrors.onSubmit = fieldValidators.onSubmit?.(validatorCtx);
+            }
+        }
+    };
+    const getFieldValue = (name) => {
+        return objGet(state, name.split("."));
+    };
+    const getFieldState = (name) => {
+        let errors = [];
+        let isValidating = false;
+        const fieldErrors = formFieldErrors[name] ?? {};
+        const asyncMeta = asyncFormFieldValidators[name] ?? {};
+        if (asyncMeta.onChangeAsync && asyncMeta.onChangeAsync.timeout !== -1) {
+            isValidating = true;
+        }
+        if (!isValidating) {
+            errors.push(...[
+                fieldErrors.onChangeAsync,
+                fieldErrors.onMount,
+                fieldErrors.onChange,
+                fieldErrors.onBlur,
+            ].filter(Boolean));
+        }
+        return {
+            value: getFieldValue(name),
+            errors,
+            isTouched: !!formFieldsTouched[name],
+            isValidating,
+        };
+    };
+    const onFieldChanged = (name) => {
+        validateField(name, "onChange");
+        if (formFieldValidators[name]?.onChangeAsync) {
+            validateField(name, "onChangeAsync");
+        }
+        if (formFieldDependencies[name]) {
+            for (const dependentOn of formFieldDependencies[name]) {
+                validateField(dependentOn, "onChange");
+                if (formFieldValidators[dependentOn]?.onChangeAsync) {
+                    validateField(dependentOn, "onChangeAsync");
+                }
+            }
+        }
+        formFieldUpdaters.get(name)?.forEach((update) => update());
+    };
+    const setFieldValue = (name, value) => {
+        objSet(state, name.split("."), value);
+        onFieldChanged(name);
+    };
+    const removeFieldMeta = (name) => {
+        for (const metaMap of [
+            formFieldErrors,
+            asyncFormFieldValidators,
+            formFieldsTouched,
+            formFieldValidators,
+        ]) {
+            delete metaMap[name];
+            for (const key in metaMap) {
+                if (key.startsWith(`${name}.`)) {
+                    delete metaMap[key];
+                }
+            }
+        }
+        formFieldUpdaters.delete(name);
+        for (const key in formFieldUpdaters) {
+            if (key.startsWith(`${name}.`)) {
+                formFieldUpdaters.delete(key);
+            }
+        }
+    };
+    const arrayFieldReplace = (name, index, value) => {
+        const path = [...name.split("."), index.toString()];
+        objSet(state, path, value);
+        removeFieldMeta(`${name}.${index}`);
+        onFieldChanged(name);
+        updateFieldComponents(name);
+    };
+    const arrayFieldPush = (name, value) => {
+        const path = [...name.split(".")];
+        const arr = objGet(state, path);
+        arr.push(value);
+        onFieldChanged(name);
+        updateFieldComponents(name);
+    };
+    const arrayFieldRemove = (name, index) => {
+        const path = [...name.split(".")];
+        const arr = objGet(state, path);
+        arr.splice(index, 1);
+        removeFieldMeta(`${name}.${index}`);
+        onFieldChanged(name);
+        updateFieldComponents(name);
+    };
+    const getErrors = () => {
+        const errors = [];
+        for (const fieldName in formFieldErrors) {
+            const meta = formFieldErrors[fieldName];
+            errors.push(...[
+                meta.onChangeAsync,
+                meta.onMount,
+                meta.onChange,
+                meta.onBlur,
+            ].filter(Boolean));
+        }
+        return errors;
+    };
+    const isAnyFieldValidating = () => {
+        for (const fieldName in asyncFormFieldValidators) {
+            const fieldValidators = asyncFormFieldValidators[fieldName];
+            if (fieldValidators.onChangeAsync &&
+                fieldValidators.onChangeAsync.timeout !== -1) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const connectField = (name, update) => {
+        if (!formFieldUpdaters.has(name)) {
+            formFieldUpdaters.set(name, new Set());
+        }
+        formFieldUpdaters.get(name).add(update);
+    };
+    const disconnectField = (name, update) => {
+        if (!formFieldUpdaters.has(name))
+            return;
+        formFieldUpdaters.get(name).delete(update);
+        const asyncValidators = asyncFormFieldValidators[name] ?? {};
+        const { abortController, timeout } = asyncValidators.onChangeAsync ?? {};
+        window.clearTimeout(timeout);
+        abortController?.abort();
+    };
+    const reset = (values) => {
+        if (values) {
+            for (const key in values) {
+                state[key] = values[key];
+            }
+        }
+        else {
+            const initialValues = (config.initialValues ?? {});
+            const keys = new Set([
+                ...Object.keys(state),
+                ...Object.keys(initialValues),
+            ]);
+            for (const key of keys) {
+                if (key in initialValues) {
+                    state[key] = structuredClone(initialValues[key]);
+                }
+                else {
+                    delete state[key];
+                }
+            }
+        }
+        for (const fieldName in formFieldsTouched) {
+            delete formFieldsTouched[fieldName];
+        }
+        for (const fieldName in asyncFormFieldValidators) {
+            const asyncFieldValidators = asyncFormFieldValidators[fieldName];
+            const { timeout, abortController } = asyncFieldValidators?.onChangeAsync ?? {};
+            if (timeout !== -1) {
+                window.clearTimeout(timeout);
+            }
+            abortController?.abort();
+            delete asyncFormFieldValidators[fieldName];
+        }
+        for (const fieldName in formFieldErrors) {
+            delete formFieldErrors[fieldName];
+        }
+        updateSubscribers();
+        formFieldUpdaters.forEach((updaters) => {
+            updaters.forEach((update) => update());
+        });
+    };
+    const validateForm = async () => {
+        var _a;
+        for (const fieldName in formFieldValidators) {
+            const fieldValidators = formFieldValidators[fieldName];
+            if (fieldValidators?.onChange) {
+                await validateField(fieldName, "onChange");
+            }
+            if (fieldValidators?.onSubmit) {
+                await validateField(fieldName, "onSubmit");
+            }
+            if (!formFieldErrors[fieldName]?.onChange &&
+                fieldValidators?.onChangeAsync) {
+                const value = state[fieldName];
+                const abortController = new AbortController();
+                const asyncValidators = (asyncFormFieldValidators[_a = fieldName] ?? (asyncFormFieldValidators[_a] = {}));
+                const epoch = asyncValidators.onChangeAsync?.epoch ?? 0;
+                asyncValidators.onChangeAsync = {
+                    timeout: 0,
+                    epoch,
+                    abortController,
+                };
+                const ctx = {
+                    value,
+                    abortSignal: abortController.signal,
+                };
+                formFieldErrors[fieldName].onChangeAsync =
+                    await fieldValidators.onChangeAsync(ctx);
+                asyncValidators.onChangeAsync = {
+                    timeout: -1,
+                    epoch,
+                    abortController: null,
+                };
+                updateFieldComponents(fieldName);
+                updateSubscribers();
+            }
+        }
+        return getErrors();
+    };
+    const deleteField = (name) => {
+        delete state[name];
+        delete formFieldErrors[name];
+        delete asyncFormFieldValidators[name];
+        delete formFieldsTouched[name];
+        delete formFieldValidators[name];
+        formFieldUpdaters.delete(name);
+        updateSubscribers();
+    };
+    const resetField = (name) => {
+        if (config.initialValues?.[name]) {
+            state[name] = config.initialValues[name];
+        }
+        else {
+            delete state[name];
+        }
+        delete formFieldErrors[name];
+        delete asyncFormFieldValidators[name];
+        delete formFieldsTouched[name];
+        updateSubscribers();
+    };
+    const getFormContext = () => {
+        return {
+            deleteField,
+            resetField,
+            setFieldValue,
+            validateForm,
+            state,
+        };
+    };
+    const setFieldValidators = (name, validators) => {
+        formFieldValidators[name] = validators;
+        if (validators.dependentOn && validators.dependentOn.length > 0) {
+            for (const dependentOn of validators.dependentOn) {
+                if (!formFieldDependencies[dependentOn]) {
+                    formFieldDependencies[dependentOn] = new Set();
+                }
+                formFieldDependencies[dependentOn].add(name);
+            }
+        }
+    };
+    return {
+        subscribers,
+        state,
+        validateField,
+        getFieldState,
+        setFieldValue,
+        arrayFieldReplace,
+        arrayFieldPush,
+        arrayFieldRemove,
+        connectField,
+        disconnectField,
+        setFieldValidators,
+        getSelectorState,
+        validateForm,
+        reset,
+        getFormContext,
+    };
+}
+export function useForm(config) {
+    return useHook("useForm", {}, ({ hook, isInit, isHMR }) => {
+        if (__DEV__) {
+            if (isInit) {
+                hook.dev = {
+                    initialArgs: [config],
+                };
+            }
+            if (isHMR) {
+                const [c] = hook.dev.initialArgs;
+                if (safeStringify(c) !== safeStringify(config)) {
+                    hook.cleanup?.();
+                    isInit = true;
+                    hook.dev.initialArgs = [config];
+                }
+            }
+        }
+        if (isInit) {
+            const $controller = (hook.formController = createFormController(config));
+            hook.Field = function Field(props) {
+                const didMount = useRef(false);
+                const update = useRequestUpdate();
+                if (props.validators) {
+                    $controller.setFieldValidators(props.name, props.validators);
+                }
+                useEffect(() => {
+                    $controller.connectField(props.name, update);
+                    if (props.validators?.onMount && !didMount.current) {
+                        didMount.current = true;
+                        $controller.validateField(props.name, "onMount");
+                    }
+                    return () => {
+                        $controller.disconnectField(props.name, update);
+                    };
+                }, []);
+                const fieldState = $controller.getFieldState(props.name);
+                const childProps = {
+                    name: props.name,
+                    state: fieldState,
+                    handleChange: (value) => {
+                        $controller.setFieldValue(props.name, value);
+                    },
+                    handleBlur: () => {
+                        $controller.validateField(props.name, "onBlur");
+                    },
+                };
+                if (props.array) {
+                    const asArrayProps = childProps;
+                    asArrayProps.items = {
+                        replace: (index, value) => {
+                            $controller.arrayFieldReplace(props.name, index, value);
+                        },
+                        push: (value) => {
+                            $controller.arrayFieldPush(props.name, value);
+                        },
+                        remove: (index) => {
+                            $controller.arrayFieldRemove(props.name, index);
+                        },
+                    };
+                }
+                return Fragment({
+                    key: useMemo(generateRandomID, []),
+                    children: props.children(childProps),
+                });
+            };
+            hook.Subscribe = function Subscribe(props) {
+                const selection = useHook("useFormSubscription", { sub: null }, ({ hook, isInit, isHMR, update }) => {
+                    if (__DEV__) {
+                        if (isHMR) {
+                            isInit = true;
+                            hook.cleanup?.();
+                        }
+                    }
+                    if (isInit) {
+                        hook.sub = {
+                            selector: props.selector,
+                            selection: props.selector($controller.getSelectorState()),
+                            update,
+                        };
+                        $controller.subscribers.add(hook.sub);
+                        hook.cleanup = () => $controller.subscribers.delete(hook.sub);
+                    }
+                    return hook.sub.selection;
+                });
+                return props.children(selection);
+            };
+        }
+        return {
+            Field: hook.Field,
+            Subscribe: hook.Subscribe,
+            handleSubmit: async () => {
+                const errors = await hook.formController.validateForm();
+                const formCtx = hook.formController.getFormContext();
+                if (errors.length)
+                    return config.onSubmitInvalid?.(formCtx);
+                await config.onSubmit?.(formCtx);
+            },
+            reset: (values) => hook.formController.reset(values),
+            getFieldState: (name) => hook.formController.getFieldState(name),
+        };
+    });
+}
+//# sourceMappingURL=index.js.map