react-store-input 0.2.5 → 0.4.0

package/dist/index.mjs

@@ -1,322 +1,612 @@
-// src/use_store_controller.tsx
-import { useEffect, useId } from "react";
+// src/store/use_store_controller.tsx
+import { useCallback, useEffect, useId, useRef } from "react";
 function useStoreController(store, props) {
   const dispatchKey = useId();
+  const propsRef = useRef(props);
+  const subscribedStoreRef = useRef(null);
   useEffect(() => {
-    const unsub = store.subscribe((state, key) => {
-      if (key === dispatchKey) {
-        return;
+    propsRef.current = props;
+  }, [props]);
+  useEffect(() => {
+    const isReplacement = subscribedStoreRef.current !== null && subscribedStoreRef.current !== store;
+    subscribedStoreRef.current = store;
+    const unsubscribe = store.subscribe((state, key) => {
+      if (key !== dispatchKey) {
+        propsRef.current.onSubscribe(state);
       }
-      props.onSubscribe(state);
     });
-    return () => {
-      unsub();
-    };
-  }, []);
-  const dispatch = () => {
+    if (isReplacement) {
+      propsRef.current.onSubscribe(store.state);
+    }
+    return unsubscribe;
+  }, [dispatchKey, store]);
+  const dispatch = useCallback(() => {
     store.dispatch(
-      (state) => {
-        props.onDispatch(state);
-      },
-      {
-        key: dispatchKey
-      }
+      (state) => propsRef.current.onDispatch(state),
+      { key: dispatchKey }
     );
+  }, [dispatchKey, store]);
+  return { dispatch };
+}
+
+// src/store/create_render.tsx
+import { useSelector } from "gw-store";
+import { Fragment, jsx } from "react/jsx-runtime";
+function createRender(store, selector, compare) {
+  function Component() {
+    const result = useSelector(store, (state) => state, compare);
+    return /* @__PURE__ */ jsx(Fragment, { children: selector(result) });
+  }
+  return /* @__PURE__ */ jsx(Component, {});
+}
+function createRenderWithStore(store) {
+  return function createRender2(selector, compare) {
+    function Component() {
+      const result = useSelector(store, (state) => state, compare);
+      return /* @__PURE__ */ jsx(Fragment, { children: selector(result) });
+    }
+    return /* @__PURE__ */ jsx(Component, {});
+  };
+}
+
+// src/binding/lens.ts
+function defineLens(lens) {
+  return lens;
+}
+function readPath(value, path) {
+  return path.reduce(
+    (current, key) => current[key],
+    value
+  );
+}
+function writePath(state, path, value) {
+  const parent = path.slice(0, -1).reduce(
+    (current, key) => current[key],
+    state
+  );
+  parent[path.at(-1)] = value;
+}
+function createPathLens(path) {
+  return {
+    get: (state) => readPath(state, path),
+    set: (state, value) => writePath(state, path, value),
+    prop: (key) => createPathLens([...path, key])
   };
+}
+function stateLens() {
   return {
-    dispatch
+    prop: (key) => createPathLens([key])
   };
 }
 
-// src/use_store_input.tsx
-import { format } from "date-fns";
-function useStoreInput(ref, store, props) {
-  const toInputValue = props.toInputValue || ((value) => {
-    if (value === void 0 || value === null) {
-      return "";
+// src/binding/codec.ts
+function defineCodec(codec) {
+  return codec;
+}
+
+// src/binding/binding.ts
+function defineBinding(binding) {
+  return binding;
+}
+
+// src/binding/laws.ts
+import { produce } from "immer";
+function structuralEqual(previous, next) {
+  if (Object.is(previous, next)) {
+    return true;
+  }
+  if (previous instanceof Date && next instanceof Date) {
+    return previous.getTime() === next.getTime();
+  }
+  if (Array.isArray(previous) && Array.isArray(next)) {
+    return previous.length === next.length && previous.every((value, index) => structuralEqual(value, next[index]));
+  }
+  if (previous !== null && next !== null && typeof previous === "object" && typeof next === "object") {
+    const previousRecord = previous;
+    const nextRecord = next;
+    const previousKeys = Reflect.ownKeys(previousRecord);
+    const nextKeys = Reflect.ownKeys(nextRecord);
+    return previousKeys.length === nextKeys.length && previousKeys.every(
+      (key) => Object.prototype.hasOwnProperty.call(nextRecord, key) && structuralEqual(previousRecord[key], nextRecord[key])
+    );
+  }
+  return false;
+}
+function assertLensLaws(lens, options) {
+  const equalsState = options.equalsState ?? structuralEqual;
+  const equalsValue = options.equalsValue ?? structuralEqual;
+  const set = (state, value) => produce(state, (draft) => lens.set(draft, value));
+  if (!equalsState(
+    set(options.state, lens.get(options.state)),
+    options.state
+  )) {
+    throw new Error("Lens law failed: setting the current value changed state.");
+  }
+  for (const value of options.values) {
+    const updated = set(options.state, value);
+    if (!equalsValue(lens.get(updated), value)) {
+      throw new Error("Lens law failed: get(set(state, value)) !== value.");
     }
-    if (props.type === "datetime-local") {
-      const date = new Date(value);
-      if (!isNaN(date.getTime())) {
-        return format(date, "yyyy-MM-dd'T'HH:mm:ss");
+  }
+  for (const previous of options.values) {
+    for (const next of options.values) {
+      if (!equalsState(
+        set(set(options.state, previous), next),
+        set(options.state, next)
+      )) {
+        throw new Error("Lens law failed: the last set did not win.");
       }
     }
-    return String(value);
-  });
-  const getDefaultValue = () => {
-    if (props.defaultValue !== void 0) {
-      return props.defaultValue;
+  }
+}
+function assertCodecLaws(codec, options) {
+  const equals = options.equals ?? codec.equals ?? structuralEqual;
+  const equalsInput = options.equalsInput ?? structuralEqual;
+  for (const value of options.values) {
+    const result = codec.parse(codec.format(value));
+    if (result.isErr) {
+      throw new Error("Codec law failed: parse(format(value)) returned Err.");
     }
-    if (props.type === "checkbox" || props.type === "radio") {
-      return void 0;
+    if (!equals(result.value, value)) {
+      throw new Error("Codec law failed: parse(format(value)) !== value.");
     }
-    return toInputValue(props.getter(store.state));
-  };
-  const toInputChecked = (value) => {
-    if (props.type === "radio") {
-      return value !== void 0 && value === props.value;
+  }
+  for (const input of options.inputs ?? []) {
+    const result = codec.parse(input);
+    if (result.isOk && !equalsInput(codec.format(result.value), input)) {
+      throw new Error(
+        "Codec law failed: format(parse(input).value) !== input."
+      );
     }
-    return Boolean(value);
-  };
-  const getDefaultChecked = () => {
-    if (props.defaultChecked) {
-      return props.defaultChecked;
+  }
+}
+
+// src/input/use_store_input.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useRef as useRef2,
+  useState
+} from "react";
+
+// src/input/dom_value.ts
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function formatDateTimeLocal(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  return [
+    date.getFullYear(),
+    "-",
+    pad(date.getMonth() + 1),
+    "-",
+    pad(date.getDate()),
+    "T",
+    pad(date.getHours()),
+    ":",
+    pad(date.getMinutes()),
+    ":",
+    pad(date.getSeconds())
+  ].join("");
+}
+function readElementValue(element) {
+  if ("options" in element && element.multiple) {
+    return Array.from(element.selectedOptions, (option) => option.value);
+  }
+  return element.value;
+}
+function writeElementValue(element, value) {
+  if ("files" in element && element.type === "file") {
+    return;
+  }
+  if ("options" in element && element.multiple) {
+    const selectedValues = new Set(
+      (Array.isArray(value) ? value : [value]).map(String)
+    );
+    for (const option of element.options) {
+      const selected = selectedValues.has(option.value);
+      if (option.selected !== selected) {
+        option.selected = selected;
+      }
     }
-    if (props.type !== "checkbox" && props.type !== "radio") {
-      return void 0;
+    return;
+  }
+  const nextValue = String(value);
+  if (element.value !== nextValue) {
+    element.value = nextValue;
+  }
+}
+function equalStateValue(previous, next) {
+  if (Object.is(previous, next)) {
+    return true;
+  }
+  if (previous instanceof Date && next instanceof Date) {
+    return Object.is(previous.getTime(), next.getTime());
+  }
+  if (Array.isArray(previous) && Array.isArray(next)) {
+    return previous.length === next.length && previous.every((value, index) => Object.is(value, next[index]));
+  }
+  return false;
+}
+
+// src/input/reset_coordinator.ts
+var resettingForms = /* @__PURE__ */ new WeakSet();
+var resetCoordinators = /* @__PURE__ */ new WeakMap();
+function isFormResetting(form) {
+  return resettingForms.has(form);
+}
+function registerResetBinding(form, batch, reset) {
+  let coordinator = resetCoordinators.get(form);
+  if (!coordinator) {
+    const groups = /* @__PURE__ */ new Map();
+    const handleReset = () => {
+      resettingForms.add(form);
+      const groupSnapshots = Array.from(groups, ([groupBatch, bindings2]) => [
+        groupBatch,
+        [...bindings2]
+      ]);
+      setTimeout(() => {
+        try {
+          for (const [groupBatch, bindings2] of groupSnapshots) {
+            groupBatch(() => {
+              for (const binding of bindings2) {
+                binding();
+              }
+            });
+          }
+        } finally {
+          setTimeout(() => resettingForms.delete(form), 0);
+        }
+      }, 0);
+    };
+    coordinator = { groups, handleReset };
+    resetCoordinators.set(form, coordinator);
+    form.addEventListener("reset", handleReset);
+  }
+  let bindings = coordinator.groups.get(batch);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Set();
+    coordinator.groups.set(batch, bindings);
+  }
+  bindings.add(reset);
+  return () => {
+    const currentCoordinator = resetCoordinators.get(form);
+    if (!currentCoordinator) {
+      return;
     }
-    return toInputChecked(props.getter(store.state));
-  };
-  const toStateValue = props.toStateValue || ((value) => {
-    if (props.type === "number" || props.type === "range") {
-      return Number(value);
+    const currentBindings = currentCoordinator.groups.get(batch);
+    currentBindings?.delete(reset);
+    if (currentBindings?.size === 0) {
+      currentCoordinator.groups.delete(batch);
     }
-    if (props.type === "datetime-local") {
-      return new Date(value);
+    if (currentCoordinator.groups.size === 0) {
+      form.removeEventListener("reset", currentCoordinator.handleReset);
+      resetCoordinators.delete(form);
     }
+  };
+}
+
+// src/input/value_conversion.ts
+function convertToInputValue(value, type) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (type === "datetime-local") {
+    return formatDateTimeLocal(value);
+  }
+  return Array.isArray(value) ? value.map(String) : String(value);
+}
+function convertToStateValue(value, type) {
+  if (Array.isArray(value)) {
     return value;
-  });
-  const inputProps = useStoreController(store, {
-    onSubscribe: (state) => {
-      const element = ref.current;
-      if (!element) {
+  }
+  if (type === "number" || type === "range") {
+    return value === "" ? void 0 : Number(value);
+  }
+  if (type === "datetime-local") {
+    if (value === "") {
+      return void 0;
+    }
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? void 0 : date;
+  }
+  return value;
+}
+function resolveDefaultValue(props, stateValue, format) {
+  if (props.type !== "radio" && props.value !== void 0) {
+    return void 0;
+  }
+  if (props.defaultValue !== void 0) {
+    return props.defaultValue;
+  }
+  if (props.type === "checkbox" || props.type === "radio" || props.type === "file") {
+    return void 0;
+  }
+  return format(stateValue);
+}
+function resolveDefaultChecked(props, stateValue, toChecked) {
+  if (props.checked !== void 0) {
+    return void 0;
+  }
+  if (props.defaultChecked !== void 0) {
+    return props.defaultChecked;
+  }
+  return props.type === "checkbox" || props.type === "radio" ? toChecked(stateValue) : void 0;
+}
+function resolveResetStateValue(props, stateValue, parse) {
+  if (props.type === "checkbox" && props.defaultChecked !== void 0) {
+    return props.defaultChecked;
+  }
+  if (props.type === "radio" && props.defaultChecked) {
+    if (props.value !== void 0) {
+      return props.value;
+    }
+    return convertToStateValue(
+      String(props.defaultValue ?? ""),
+      props.type
+    );
+  }
+  if (props.type !== "file" && props.type !== "checkbox" && props.type !== "radio" && props.defaultValue !== void 0) {
+    const defaultValue = Array.isArray(props.defaultValue) ? props.defaultValue.map(String) : String(props.defaultValue);
+    return parse(defaultValue);
+  }
+  return stateValue;
+}
+
+// src/input/use_store_input.tsx
+function isDisplayValue(value) {
+  return typeof value === "string" || typeof value === "number" || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function readControlValue(element, type, radioValue) {
+  if ("files" in element && type === "file") {
+    return element.files?.length ? element.files : null;
+  }
+  if ("checked" in element && type === "checkbox") {
+    return element.checked;
+  }
+  if ("checked" in element && type === "radio") {
+    return element.checked ? radioValue ?? element.value : void 0;
+  }
+  return readElementValue(element);
+}
+function useStoreInput(ref, store, binding, options = {}) {
+  const props = options;
+  const getStateValue = binding.lens.get;
+  const setStoreValue = binding.lens.set;
+  const [meta, setMeta] = useState({ valid: true });
+  const metaRef = useRef2(meta);
+  const formatValue = useCallback2(
+    (value) => binding.codec.format(value),
+    [binding]
+  );
+  const parseValue = useCallback2(
+    (value) => binding.codec.parse(value),
+    [binding]
+  );
+  const toChecked = useCallback2(
+    (value) => props.type === "radio" ? Object.is(formatValue(value), props.value) : Boolean(formatValue(value)),
+    [formatValue, props.type, props.value]
+  );
+  const initialStateValue = getStateValue(store.state);
+  const resetValueRef = useRef2(
+    Object.prototype.hasOwnProperty.call(options, "resetValue") ? options.resetValue : initialStateValue
+  );
+  const setStateValue = useCallback2(
+    (state, value) => {
+      const equals = binding.codec.equals ?? equalStateValue;
+      if (equals(getStateValue(store.state), value)) {
         return;
       }
-      if ("checked" in element && (props.type === "checkbox" || props.type === "radio")) {
-        const checked = toInputChecked(props.getter(state));
-        if (element.checked === checked) {
-          return;
-        }
-        element.checked = checked;
-      } else {
-        const value = toInputValue(props.getter(state));
-        if (element.value === value) {
-          return;
-        }
-        element.value = value;
+      setStoreValue(state, value);
+    },
+    [binding, getStateValue, setStoreValue, store]
+  );
+  const commitValue = useCallback2(
+    (state, controlValue) => {
+      const result = parseValue(controlValue);
+      if (result.isErr) {
+        const invalidMeta = {
+          valid: false,
+          error: result.error
+        };
+        metaRef.current = invalidMeta;
+        setMeta(invalidMeta);
+        return;
       }
-      const event = new Event("input", { bubbles: true });
-      element.dispatchEvent(event);
+      const validMeta = { valid: true };
+      metaRef.current = validMeta;
+      setMeta((current) => current.valid ? current : validMeta);
+      setStateValue(state, result.value);
     },
-    onDispatch: (state) => {
-      const element = ref.current;
-      if (!element) {
+    [parseValue, setStateValue]
+  );
+  const writeValue = useCallback2(
+    (element, value) => {
+      if ("checked" in element && (props.type === "checkbox" || props.type === "radio")) {
+        element.checked = toChecked(value);
         return;
       }
-      if ("checked" in element && props.type === "checkbox") {
-        props.setter(state, element.checked);
-      } else {
-        props.setter(state, toStateValue(element.value));
+      if ("files" in element && props.type === "file") {
+        return;
       }
-    }
-  });
-  return {
-    defaultValue: getDefaultValue(),
-    defaultChecked: getDefaultChecked(),
-    onChange: (event) => {
-      inputProps.dispatch();
-      props.onChange?.(event);
-    }
-  };
-}
-
-// src/use_store_input_with_name.tsx
-function useStoreInputWithName(ref, store, props) {
-  const inputProps = useStoreInput(ref, store, {
-    ...props,
-    getter: (state) => {
-      if (props.getter) {
-        return props.getter(state);
+      const formatted = formatValue(value);
+      if (isDisplayValue(formatted)) {
+        writeElementValue(element, formatted);
       }
-      return state[props.name];
     },
-    setter: (state, value) => {
-      if (props.setter) {
-        props.setter(state, value);
-        return;
-      }
-      state[props.name] = value;
-    }
-  });
-  return {
-    ...inputProps,
-    name: "name" in props ? String(props.name) : void 0
-  };
-}
-
-// src/use_store_component.tsx
-import { useCallback, useRef as useRef2 } from "react";
-
-// src/text_editor.tsx
-import {
-  TextEditor as GwTextEditor
-} from "gw-react-text-editor";
-import { useImperativeHandle, useRef } from "react";
-import { jsx } from "react/jsx-runtime";
-function TextEditor({
-  store,
-  name,
-  getter,
-  setter,
-  defaultValue,
-  ref,
-  ...props
-}) {
-  const controllerRef = useRef(null);
-  useImperativeHandle(
-    ref,
-    () => controllerRef.current,
-    []
+    [formatValue, props.type, toChecked]
   );
   const { dispatch } = useStoreController(store, {
     onSubscribe: (state) => {
-      const controller = controllerRef.current;
-      if (!controller) {
+      const element = ref.current;
+      if (!element || !metaRef.current.valid || element.form && isFormResetting(element.form) || props.type !== "radio" && props.value !== void 0) {
         return;
       }
-      const getResult = () => {
-        if (getter) {
-          return getter(state) || "";
-        }
-        if (name) {
-          return state[name] || "";
-        }
-        return "";
-      };
-      const result = getResult();
-      if (controller.value !== result) {
-        controller.value = result;
+      if ("checked" in element && (props.type === "checkbox" || props.type === "radio") && props.checked !== void 0) {
+        return;
       }
+      writeValue(element, getStateValue(state));
     },
     onDispatch: (state) => {
-      const controller = controllerRef.current;
-      if (!controller) {
-        return;
-      }
-      if (setter) {
-        setter(state, controller.value);
+      const element = ref.current;
+      if (!element) {
         return;
       }
-      if (name) {
-        state[name] = controller.value;
+      const controlValue = readControlValue(element, props.type, props.value);
+      if (controlValue !== void 0) {
+        commitValue(state, controlValue);
       }
     }
   });
-  const getDefaultValue = () => {
-    if (getter) {
-      return getter(store.state);
-    }
-    if (name) {
-      return store.state[name];
+  useEffect2(() => {
+    const element = ref.current;
+    const form = element?.form;
+    if (!element || !form) {
+      return;
     }
-    return void 0;
-  };
-  return /* @__PURE__ */ jsx(
-    GwTextEditor,
-    {
-      ...props,
-      ref: controllerRef,
-      defaultValue: defaultValue ?? getDefaultValue(),
-      onChange: (e) => {
-        dispatch();
-        props.onChange?.(e);
+    return registerResetBinding(form, store.batch, () => {
+      if (!element.isConnected) {
+        return;
       }
+      const resetValue = resetValueRef.current;
+      const writeResetValue = () => writeValue(element, resetValue);
+      writeResetValue();
+      const validMeta = { valid: true };
+      metaRef.current = validMeta;
+      setMeta((current) => current.valid ? current : validMeta);
+      store.dispatch((state) => setStateValue(state, resetValue));
+      setTimeout(() => {
+        if (element.isConnected) {
+          writeResetValue();
+        }
+      }, 0);
+    });
+  }, [ref, setStateValue, store, store.batch, writeValue]);
+  const inputProps = {
+    defaultValue: resolveDefaultValue(props, initialStateValue, (value) => {
+      const formatted = formatValue(value);
+      return isDisplayValue(formatted) ? formatted : "";
+    }),
+    defaultChecked: resolveDefaultChecked(
+      props,
+      initialStateValue,
+      toChecked
+    ),
+    onChange: (event) => {
+      dispatch();
+      props.onChange?.(event);
     }
-  );
+  };
+  return { inputProps, meta };
 }
 
-// src/use_store_component.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-function useStoreComponent(store) {
-  const input = useCallback(function Component(props) {
-    return /* @__PURE__ */ jsx2(Input, { store, ...props });
-  }, []);
-  const select = useCallback(function Component(props) {
-    return /* @__PURE__ */ jsx2(Select, { store, ...props });
-  }, []);
-  const textarea = useCallback(function Component(props) {
-    return /* @__PURE__ */ jsx2(Textarea, { store, ...props });
-  }, []);
-  const textEditor = useCallback(function Component(props) {
-    return /* @__PURE__ */ jsx2(TextEditor, { store, ...props });
-  }, []);
+// src/input/use_store_input_with_name.tsx
+import { useMemo } from "react";
+import { ok } from "gw-result";
+function formatControlValue(value, type) {
+  if (type === "checkbox") {
+    return Boolean(value);
+  }
+  if (type === "radio" || type === "file") {
+    return value;
+  }
+  return convertToInputValue(value, type);
+}
+function parseControlValue(value, type) {
+  if (typeof value === "string" || Array.isArray(value)) {
+    const stateInputValue = Array.isArray(value) ? [...value] : value;
+    return convertToStateValue(stateInputValue, type);
+  }
+  return value;
+}
+function useStoreInputWithName(ref, store, props) {
+  const binding = useMemo(
+    () => ({
+      lens: {
+        get: (state) => state[props.name],
+        set: (state, value) => {
+          state[props.name] = value;
+        }
+      },
+      codec: {
+        format: (value) => formatControlValue(value, props.type),
+        parse: (value) => ok(parseControlValue(value, props.type))
+      }
+    }),
+    [props.name, props.type]
+  );
+  const initialStateValue = binding.lens.get(store.state);
+  const resetValue = resolveResetStateValue(
+    props,
+    initialStateValue,
+    (value) => parseControlValue(value, props.type)
+  );
+  const { inputProps } = useStoreInput(ref, store, binding, {
+    ...props,
+    resetValue
+  });
   return {
-    input,
-    select,
-    textarea,
-    textEditor
+    ...inputProps,
+    name: String(props.name)
   };
 }
+
+// src/form/store_components.tsx
+import {
+  useCallback as useCallback3,
+  useRef as useRef3
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
 function Input({
   store,
-  getter,
-  setter,
-  toInputValue,
-  toStateValue,
   ...props
 }) {
-  const ref = useRef2(null);
-  const storeProps = useStoreInputWithName(ref, store, {
-    ...props,
-    getter,
-    setter,
-    toInputValue,
-    toStateValue
-  });
+  const ref = useRef3(null);
+  const storeProps = useStoreInputWithName(ref, store, props);
   return /* @__PURE__ */ jsx2("input", { ref, ...props, ...storeProps });
 }
 function Select({
   store,
-  getter,
-  setter,
-  toInputValue,
-  toStateValue,
   ...props
 }) {
-  const ref = useRef2(null);
-  const storeProps = useStoreInputWithName(ref, store, {
-    ...props,
-    getter,
-    setter,
-    toInputValue,
-    toStateValue
-  });
+  const ref = useRef3(null);
+  const storeProps = useStoreInputWithName(ref, store, props);
   return /* @__PURE__ */ jsx2("select", { ref, ...props, ...storeProps });
 }
 function Textarea({
   store,
-  getter,
-  setter,
-  toInputValue,
-  toStateValue,
   ...props
 }) {
-  const ref = useRef2(null);
-  const storeProps = useStoreInputWithName(ref, store, {
-    ...props,
-    getter,
-    setter,
-    toInputValue,
-    toStateValue
-  });
+  const ref = useRef3(null);
+  const storeProps = useStoreInputWithName(ref, store, props);
   return /* @__PURE__ */ jsx2("textarea", { ref, ...props, ...storeProps });
 }
-
-// src/create_render.tsx
-import { useSelector } from "gw-store";
-import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
-function createRenderWithStore(store) {
-  return function createRender(selector, compare) {
-    function Component() {
-      const result = useSelector(store, (state) => state, compare);
-      const content = selector(result);
-      return /* @__PURE__ */ jsx3(Fragment, { children: content });
-    }
-    return /* @__PURE__ */ jsx3(Component, {});
-  };
+function useStoreComponent(store) {
+  const input = useCallback3(
+    function Component(props) {
+      return /* @__PURE__ */ jsx2(Input, { store, ...props });
+    },
+    [store]
+  );
+  const select = useCallback3(
+    function Component(props) {
+      return /* @__PURE__ */ jsx2(Select, { store, ...props });
+    },
+    [store]
+  );
+  const textarea = useCallback3(
+    function Component(props) {
+      return /* @__PURE__ */ jsx2(Textarea, { store, ...props });
+    },
+    [store]
+  );
+  return { input, select, textarea };
 }
 
-// src/use_form_store.tsx
+// src/form/use_form_store.tsx
 import { useStore } from "gw-store";
 function useFormStore(initialState) {
   const store = useStore(initialState);
@@ -326,19 +616,34 @@ function useFormStore(initialState) {
       return store.state;
     },
     dispatch: store.dispatch,
+    batch: store.batch,
     subscribe: store.subscribe,
     render: createRenderWithStore(store),
     ...storeComponent
   };
 }
+
+// src/index.tsx
+import { err, ok as ok2 } from "gw-result";
+export * from "gw-store";
 export {
   Input,
   Select,
-  TextEditor,
   Textarea,
+  assertCodecLaws,
+  assertLensLaws,
+  createRender,
+  createRenderWithStore,
+  defineBinding,
+  defineCodec,
+  defineLens,
+  err,
+  ok2 as ok,
+  stateLens,
   useFormStore,
   useStoreComponent,
   useStoreController,
   useStoreInput,
   useStoreInputWithName
 };
+//# sourceMappingURL=index.mjs.map