@vobs/forms 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -0,0 +1,1346 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = owner?.handleError(error) ?? false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function readDebugValue(read) {
+  try {
+    return read();
+  } catch {
+    return "[Uninspectable]";
+  }
+}
+__name(readDebugValue, "readDebugValue");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function registerHmrInstance(moduleId, instance) {
+  const instances = getModule(moduleId).instances;
+  instances.add(instance);
+  return () => instances.delete(instance);
+}
+__name(registerHmrInstance, "registerHmrInstance");
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+function getModule(moduleId) {
+  let module = hmrGlobal.modules.get(moduleId);
+  if (!module) {
+    module = { components: /* @__PURE__ */ new Map(), state: /* @__PURE__ */ new Map(), instances: /* @__PURE__ */ new Set() };
+    hmrGlobal.modules.set(moduleId, module);
+  }
+  return module;
+}
+__name(getModule, "getModule");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+function associateHmrInstance(node, instance) {
+  hmrInstances.set(node, instance);
+}
+__name(associateHmrInstance, "associateHmrInstance");
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+var eventBindings = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createText(content) {
+  return getRenderer().createText(content);
+}
+__name(createText, "createText");
+function createElement(tag) {
+  return getRenderer().createElement(tag);
+}
+__name(createElement, "createElement");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function setProperty(node, key, value) {
+  getRenderer().setProperty(node, key, value);
+}
+__name(setProperty, "setProperty");
+function setAttribute(node, key, value) {
+  getRenderer().setAttribute(node, key, value);
+}
+__name(setAttribute, "setAttribute");
+function addEventListener(node, event, handler) {
+  const renderer = getRenderer();
+  const owner = getCurrentOwner();
+  let bindings = eventBindings.get(node);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Map();
+    eventBindings.set(node, bindings);
+  }
+  const previous = bindings.get(event);
+  if (previous && previous.original === handler && previous.owner === owner) return;
+  if (previous) renderer.removeEventListener(node, event, previous.handler);
+  const listener = owner ? (reason) => {
+    try {
+      owner.run(() => handler(reason));
+    } catch (error) {
+      const handled = owner.handleError(error);
+      invokeRuntimeDebug("error", {
+        error,
+        owner,
+        phase: "event",
+        handled,
+        recovery: handled ? "handled" : "propagated"
+      });
+      if (!handled) throw error;
+    }
+  } : handler;
+  const binding = { handler: listener, owner, original: handler };
+  bindings.set(event, binding);
+  renderer.addEventListener(node, event, listener);
+  owner?.onDispose(() => {
+    if (bindings?.get(event) !== binding) return;
+    bindings.delete(event);
+    renderer.removeEventListener(node, event, listener);
+  });
+}
+__name(addEventListener, "addEventListener");
+function createComponent(component, props, source) {
+  const owner = createOwner();
+  const componentName = component.displayName || component.name || "anonymous";
+  setOwnerDebugName(owner, source ? `${componentName} (${source.file}:${source.line}:${source.column})` : componentName);
+  owner.onError((reason) => {
+    attachSourceLocation(reason, source);
+    attachComponentContext(reason, componentName, owner.id);
+    throw reason;
+  });
+  let node;
+  try {
+    node = owner.run(() => component(props));
+  } catch (error) {
+    owner.dispose();
+    attachSourceLocation(error, source);
+    attachComponentContext(error, componentName, owner.id);
+    throw error;
+  }
+  associateNodeOwner(node, owner);
+  const hmrKey = component.hmrKey;
+  if (hmrKey) {
+    const instance = {
+      node,
+      parent: null,
+      refresh() {
+        const previous = instance.node;
+        const next = owner.run(() => component(props));
+        if (instance.parent && !isVobsFragment(previous) && !isVobsFragment(next)) {
+          getRenderer().insertBefore(instance.parent, next, previous);
+          getRenderer().removeChild(instance.parent, previous);
+        }
+        nodeOwners.delete(previous);
+        nodeOwners.set(next, owner);
+        associateHmrInstance(next, instance);
+        instance.node = next;
+      }
+    };
+    associateHmrInstance(node, instance);
+    const separator = hmrKey.lastIndexOf(":");
+    const moduleId = separator < 0 ? hmrKey : hmrKey.slice(0, separator);
+    const cleanup = registerHmrInstance(moduleId, instance);
+    owner.onDispose(cleanup);
+  }
+  return node;
+}
+__name(createComponent, "createComponent");
+function attachSourceLocation(reason, source) {
+  if (!source || (!reason || typeof reason !== "object" && typeof reason !== "function")) return;
+  const error = reason;
+  if (error.vobsSource) return;
+  try {
+    Object.defineProperty(error, "vobsSource", {
+      configurable: true,
+      enumerable: false,
+      value: source,
+      writable: false
+    });
+  } catch {
+  }
+}
+__name(attachSourceLocation, "attachSourceLocation");
+function attachComponentContext(reason, component, ownerId) {
+  if (!reason || typeof reason !== "object" && typeof reason !== "function") return;
+  const error = reason;
+  try {
+    if (!error.vobsComponent) Object.defineProperty(error, "vobsComponent", { configurable: true, enumerable: false, value: component, writable: false });
+    if (!error.vobsOwnerId) Object.defineProperty(error, "vobsOwnerId", { configurable: true, enumerable: false, value: ownerId, writable: false });
+  } catch {
+  }
+}
+__name(attachComponentContext, "attachComponentContext");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const owner = getCurrentOwner();
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/forms/src/field.ts
+function Field(props) {
+  const field = props.form.field(props.name);
+  return createFragment((parent, anchor) => {
+    const wrapper = createElement("div");
+    setAttribute(wrapper, "data-vobs-field", props.name);
+    insertBefore(parent, wrapper, anchor);
+    if (props.label) {
+      const label = createElement("label");
+      insertBefore(label, createText(props.label), null);
+      insertBefore(wrapper, label, null);
+    }
+    if (props.children) {
+      const child = props.children(field);
+      if (child) insertBefore(wrapper, child, null);
+    } else if (props.component) {
+      const { form: _form, name: _name, label: _label, children: _children, component: _component, ...extra } = props;
+      const wired = createComponent(props.component, {
+        ...extra,
+        get value() {
+          return field.value.value;
+        },
+        onInput: /* @__PURE__ */ __name((event) => {
+          field.set(event.target.value);
+        }, "onInput"),
+        onBlur: /* @__PURE__ */ __name(() => {
+          void field.markTouched();
+        }, "onBlur")
+      });
+      insertBefore(wrapper, wired, null);
+    } else {
+      const input = createElement("input");
+      effect(() => setProperty(input, "value", field.value.value));
+      addEventListener(input, "input", (event) => {
+        field.set(event.target.value);
+      });
+      addEventListener(input, "blur", () => {
+        void field.markTouched();
+      });
+      insertBefore(wrapper, input, null);
+    }
+    insertDynamic(wrapper, null, () => {
+      if (!field.touched.value || !field.error.value) return null;
+      const error = createElement("span");
+      setAttribute(error, "data-vobs-field-error", "");
+      insertBefore(error, createText(field.error.value), null);
+      return error;
+    });
+  });
+}
+__name(Field, "Field");
+
+// packages/forms/src/form.ts
+var FORM_DISPOSED = "Vobs forms: \u8868\u5355\u5DF2\u9500\u6BC1";
+function useForm(initialValues, options = {}) {
+  return createForm(initialValues, options);
+}
+__name(useForm, "useForm");
+function createForm(initialValues, options = {}) {
+  const owner = createOwner();
+  const names = Object.keys(initialValues);
+  const fields = /* @__PURE__ */ new Map();
+  const touchedNames = /* @__PURE__ */ new Set();
+  const validatingNames = /* @__PURE__ */ new Set();
+  const dirty = owner.run(() => state(false));
+  const touched = owner.run(() => state(/* @__PURE__ */ new Set()));
+  const errors = owner.run(() => state({}));
+  const hasErrors = owner.run(() => state(false));
+  const submitting = owner.run(() => state(false));
+  const validating = owner.run(() => state(false));
+  const validatingFields = owner.run(() => state(/* @__PURE__ */ new Set()));
+  const fieldNames = owner.run(() => state(new Set(names)));
+  let schemaRun = 0;
+  let schemaPending = 0;
+  let formError = null;
+  let disposed = false;
+  let submitPromise = null;
+  owner.run(() => {
+    for (const name of names) {
+      const initialValue = initialValues[name];
+      fields.set(name, {
+        name,
+        value: state(initialValue),
+        touched: state(false),
+        dirty: state(false),
+        error: state(null),
+        validating: state(false),
+        initialValue,
+        validationRun: 0
+      });
+    }
+  });
+  const values = createValuesProxy(fields);
+  function assertActive() {
+    if (disposed) throw new Error(FORM_DISPOSED);
+  }
+  __name(assertActive, "assertActive");
+  function getInternalField(name) {
+    const field = fields.get(name);
+    if (!field) throw new Error(`Vobs forms: \u672A\u5B9A\u4E49\u5B57\u6BB5 "${name}"`);
+    return field;
+  }
+  __name(getInternalField, "getInternalField");
+  function updateAggregateErrors() {
+    const next = {};
+    if (formError) next.__form = formError;
+    for (const name of names) {
+      const error = fields.get(name).error.value;
+      if (error) next[name] = error;
+    }
+    errors.value = next;
+    hasErrors.value = Object.keys(next).length > 0;
+  }
+  __name(updateAggregateErrors, "updateAggregateErrors");
+  function setFieldError(name, message) {
+    const field = getInternalField(name);
+    field.error.value = message;
+    updateAggregateErrors();
+  }
+  __name(setFieldError, "setFieldError");
+  function setFormError(message) {
+    formError = message;
+    updateAggregateErrors();
+  }
+  __name(setFormError, "setFormError");
+  function updateDirty() {
+    dirty.value = names.some((name) => fields.get(name).dirty.value);
+  }
+  __name(updateDirty, "updateDirty");
+  function updateValidating() {
+    validating.value = validatingNames.size > 0 || schemaPending > 0;
+  }
+  __name(updateValidating, "updateValidating");
+  function setFieldValidating(name, active) {
+    const field = getInternalField(name);
+    field.validating.value = active;
+    const typedName = name;
+    if (active) validatingNames.add(typedName);
+    else validatingNames.delete(typedName);
+    validatingFields.value = new Set(validatingNames);
+    updateValidating();
+  }
+  __name(setFieldValidating, "setFieldValidating");
+  function normalizeMessage(value) {
+    if (value === void 0 || value === null || value === "" || value === false) return null;
+    if (value instanceof Error) return value.message || "\u6821\u9A8C\u5931\u8D25";
+    return String(value);
+  }
+  __name(normalizeMessage, "normalizeMessage");
+  function validatorList(name) {
+    const field = fields.get(name);
+    if (field?.validators) return field.validators;
+    const configured = options.validators?.[name];
+    if (!configured) return [];
+    return Array.isArray(configured) ? configured : [configured];
+  }
+  __name(validatorList, "validatorList");
+  function runValidators(name, value, snapshot, signal) {
+    const validators = validatorList(name);
+    let index = 0;
+    const next = /* @__PURE__ */ __name(() => {
+      while (index < validators.length) {
+        const validator = validators[index++];
+        let result;
+        try {
+          result = validator(value, snapshot, signal);
+        } catch (error) {
+          if (signal.aborted) return null;
+          return normalizeMessage(error) ?? "\u6821\u9A8C\u5931\u8D25";
+        }
+        if (isPromiseLike(result)) {
+          return Promise.resolve(result).then(
+            (message2) => normalizeMessage(message2) ?? next(),
+            (error) => signal.aborted ? null : normalizeMessage(error) ?? "\u6821\u9A8C\u5931\u8D25"
+          );
+        }
+        const message = normalizeMessage(result);
+        if (message) return message;
+      }
+      return null;
+    }, "next");
+    return next();
+  }
+  __name(runValidators, "runValidators");
+  function runSchema(snapshot) {
+    if (!options.schema) return {};
+    try {
+      const result = options.schema.validate(snapshot);
+      if (isPromiseLike(result)) {
+        return Promise.resolve(result).then(normalizeErrors, (error) => ({
+          __form: normalizeMessage(error) ?? "\u6821\u9A8C\u5931\u8D25"
+        }));
+      }
+      return normalizeErrors(result);
+    } catch (error) {
+      return { __form: normalizeMessage(error) ?? "\u6821\u9A8C\u5931\u8D25" };
+    }
+  }
+  __name(runSchema, "runSchema");
+  function normalizeErrors(value) {
+    if (!value || typeof value !== "object") return {};
+    const result = {};
+    for (const [name, message] of Object.entries(value)) {
+      const normalized = normalizeMessage(message);
+      if (normalized) result[name] = normalized;
+    }
+    return result;
+  }
+  __name(normalizeErrors, "normalizeErrors");
+  function applyValidation(name, run, result) {
+    const field = fields.get(name);
+    const message = normalizeMessage(result);
+    if (!disposed && field && field.validationRun === run) setFieldError(name, message);
+    return message;
+  }
+  __name(applyValidation, "applyValidation");
+  function debounceFor(name, field) {
+    if (field.validateDebounce !== void 0) return field.validateDebounce;
+    if (typeof options.validateDebounce === "number") return options.validateDebounce;
+    return options.validateDebounce?.[name] ?? 0;
+  }
+  __name(debounceFor, "debounceFor");
+  function cancelFieldValidation(field) {
+    field.validationRun++;
+    field.controller?.abort();
+    field.controller = void 0;
+    if (field.debounceCancel) field.debounceCancel();
+    if (field.debounceTimer !== void 0) clearTimeout(field.debounceTimer);
+    field.debounceTimer = void 0;
+    field.debounceCancel = void 0;
+  }
+  __name(cancelFieldValidation, "cancelFieldValidation");
+  function beginFieldValidation(field) {
+    field.controller?.abort();
+    if (field.debounceCancel) field.debounceCancel();
+    if (field.debounceTimer !== void 0) clearTimeout(field.debounceTimer);
+    field.debounceCancel = void 0;
+    const controller = new AbortController();
+    field.controller = controller;
+    return controller;
+  }
+  __name(beginFieldValidation, "beginFieldValidation");
+  function validateFieldInternal(name, includeSchema) {
+    assertActive();
+    const field = getInternalField(name);
+    const run = ++field.validationRun;
+    const controller = beginFieldValidation(field);
+    const snapshot = snapshotValues(fields);
+    const execute = /* @__PURE__ */ __name(() => runValidators(name, field.value.value, snapshot, controller.signal), "execute");
+    const delay = debounceFor(name, field);
+    const fieldResult = delay > 0 ? new Promise((resolve) => {
+      field.debounceCancel = () => resolve(null);
+      field.debounceTimer = setTimeout(() => {
+        field.debounceTimer = void 0;
+        field.debounceCancel = void 0;
+        resolve(execute());
+      }, delay);
+    }) : execute();
+    const finish = /* @__PURE__ */ __name((message) => {
+      if (!includeSchema || !options.schema) return applyValidation(name, run, message);
+      const schemaResult = runSchema(snapshot);
+      if (isPromiseLike(schemaResult)) {
+        schemaPending++;
+        updateValidating();
+        return Promise.resolve(schemaResult).then((schemaErrors) => {
+          const schemaMessage = schemaErrors[name];
+          setFormError(schemaErrors.__form ?? null);
+          return applyValidation(name, run, schemaMessage ?? message);
+        }).finally(() => {
+          schemaPending--;
+          updateValidating();
+        });
+      }
+      setFormError(schemaResult.__form ?? null);
+      return applyValidation(name, run, schemaResult[name] ?? message);
+    }, "finish");
+    if (isPromiseLike(fieldResult)) {
+      setFieldValidating(name, true);
+      return Promise.resolve(fieldResult).then(finish).finally(() => {
+        if (!disposed && field.validationRun === run) {
+          field.controller = void 0;
+          field.debounceCancel = void 0;
+          setFieldValidating(name, false);
+        }
+      });
+    }
+    field.controller = void 0;
+    field.debounceCancel = void 0;
+    if (!disposed && field.validationRun === run) setFieldValidating(name, false);
+    return finish(fieldResult);
+  }
+  __name(validateFieldInternal, "validateFieldInternal");
+  function validateField(name) {
+    return validateFieldInternal(name, true);
+  }
+  __name(validateField, "validateField");
+  function applyAllErrors(fieldErrors, schemaErrors) {
+    const result = {};
+    setFormError(schemaErrors.__form ?? null);
+    if (schemaErrors.__form) result.__form = schemaErrors.__form;
+    for (const name of names) {
+      const errorName = name;
+      const message = schemaErrors[errorName] ?? fieldErrors[errorName] ?? null;
+      setFieldError(name, message);
+      if (message) result[errorName] = message;
+    }
+    return result;
+  }
+  __name(applyAllErrors, "applyAllErrors");
+  function validateAll() {
+    assertActive();
+    for (const name of names) {
+      const field = fields.get(name);
+      field.touched.value = true;
+      touchedNames.add(name);
+    }
+    touched.value = new Set(touchedNames);
+    const currentSchemaRun = ++schemaRun;
+    const fieldResults = names.map((name) => validateFieldInternal(name, false));
+    const schemaResult = options.schema ? runSchema(snapshotValues(fields)) : {};
+    const combine = /* @__PURE__ */ __name((fieldMessages, schemaErrors) => {
+      if (currentSchemaRun !== schemaRun) return {};
+      const fieldErrors = {};
+      names.forEach((name, index) => {
+        if (fieldMessages[index]) fieldErrors[name] = fieldMessages[index];
+      });
+      return applyAllErrors(fieldErrors, schemaErrors);
+    }, "combine");
+    if (fieldResults.some(isPromiseLike) || isPromiseLike(schemaResult)) {
+      if (isPromiseLike(schemaResult)) {
+        schemaPending++;
+        updateValidating();
+      }
+      return Promise.all(fieldResults.map((result) => Promise.resolve(result))).then((fieldMessages) => {
+        if (isPromiseLike(schemaResult)) {
+          return Promise.resolve(schemaResult).then((schemaErrors) => combine(fieldMessages, schemaErrors));
+        }
+        return combine(fieldMessages, schemaResult);
+      }).finally(() => {
+        if (isPromiseLike(schemaResult)) {
+          schemaPending--;
+          updateValidating();
+        }
+      }).then((result) => result);
+    }
+    return combine(fieldResults, schemaResult);
+  }
+  __name(validateAll, "validateAll");
+  function fieldApi(name) {
+    const field = getInternalField(name);
+    return {
+      name,
+      value: field.value,
+      touched: field.touched,
+      dirty: field.dirty,
+      error: field.error,
+      validating: field.validating,
+      set(value) {
+        assertActive();
+        const nextValue = value;
+        field.value.value = nextValue;
+        field.dirty.value = !Object.is(nextValue, field.initialValue);
+        field.error.value = null;
+        updateAggregateErrors();
+        updateDirty();
+        if (options.validateOn === "input") void settle(validateField(name));
+      },
+      markTouched() {
+        assertActive();
+        field.touched.value = true;
+        touchedNames.add(name);
+        touched.value = new Set(touchedNames);
+        return options.validateOn === "blur" ? validateField(name) : null;
+      },
+      validate() {
+        return validateField(name);
+      },
+      reset(value) {
+        assertActive();
+        cancelFieldValidation(field);
+        setFieldValidating(name, false);
+        const nextValue = arguments.length === 0 ? field.initialValue : value;
+        field.initialValue = nextValue;
+        field.value.value = nextValue;
+        field.dirty.value = false;
+        field.touched.value = false;
+        touchedNames.delete(name);
+        field.error.value = null;
+        touched.value = new Set(touchedNames);
+        updateAggregateErrors();
+        updateDirty();
+      }
+    };
+  }
+  __name(fieldApi, "fieldApi");
+  function addField(name, initialValue, fieldOptions = {}) {
+    assertActive();
+    if (!name) throw new Error("Vobs forms: \u5B57\u6BB5\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+    if (fields.has(name)) throw new Error(`Vobs forms: \u5B57\u6BB5 "${name}" \u5DF2\u5B58\u5728`);
+    const validators = fieldOptions.validators ? Array.isArray(fieldOptions.validators) ? fieldOptions.validators : [fieldOptions.validators] : void 0;
+    fields.set(name, {
+      name,
+      value: state(initialValue),
+      touched: state(false),
+      dirty: state(false),
+      error: state(null),
+      validating: state(false),
+      initialValue,
+      validationRun: 0,
+      validators,
+      validateDebounce: fieldOptions.validateDebounce
+    });
+    names.push(name);
+    fieldNames.value = new Set(names);
+    return fieldApi(name);
+  }
+  __name(addField, "addField");
+  function removeField(name) {
+    assertActive();
+    const field = fields.get(name);
+    if (!field) return false;
+    cancelFieldValidation(field);
+    setFieldValidating(name, false);
+    fields.delete(name);
+    const index = names.indexOf(name);
+    if (index >= 0) names.splice(index, 1);
+    touchedNames.delete(name);
+    fieldNames.value = new Set(names);
+    touched.value = new Set(touchedNames);
+    updateAggregateErrors();
+    updateDirty();
+    return true;
+  }
+  __name(removeField, "removeField");
+  function setServerErrors(serverErrors) {
+    assertActive();
+    for (const [name, message] of Object.entries(serverErrors)) {
+      if (name === "__form") {
+        setFormError(normalizeMessage(message));
+        continue;
+      }
+      if (!fields.has(name)) continue;
+      setFieldError(name, normalizeMessage(message));
+    }
+  }
+  __name(setServerErrors, "setServerErrors");
+  function clearErrors(name) {
+    assertActive();
+    if (name === "__form") {
+      setFormError(null);
+      return;
+    }
+    const targets = name ? [name] : names;
+    for (const target of targets) {
+      const field = getInternalField(target);
+      cancelFieldValidation(field);
+      setFieldValidating(target, false);
+      field.error.value = null;
+    }
+    if (!name) setFormError(null);
+    updateAggregateErrors();
+  }
+  __name(clearErrors, "clearErrors");
+  function getErrorFields() {
+    return names.filter((name) => Boolean(fields.get(name).error.value));
+  }
+  __name(getErrorFields, "getErrorFields");
+  function reset(nextValues = {}) {
+    assertActive();
+    schemaRun++;
+    setFormError(null);
+    for (const name of names) {
+      const field = getInternalField(name);
+      cancelFieldValidation(field);
+      setFieldValidating(name, false);
+      const nextValue = Object.prototype.hasOwnProperty.call(nextValues, name) ? nextValues[name] : field.initialValue;
+      field.initialValue = nextValue;
+      field.value.value = nextValue;
+      field.dirty.value = false;
+      field.touched.value = false;
+      field.error.value = null;
+    }
+    touchedNames.clear();
+    touched.value = /* @__PURE__ */ new Set();
+    updateAggregateErrors();
+    updateDirty();
+  }
+  __name(reset, "reset");
+  function submit(handler) {
+    assertActive();
+    if (submitPromise) return submitPromise;
+    const submitHandler = handler ?? options.onSubmit;
+    const run = /* @__PURE__ */ __name(async () => {
+      submitting.value = true;
+      try {
+        const validationErrors = await validateAll();
+        if (Object.keys(validationErrors).length > 0) {
+          return { valid: false, errors: validationErrors };
+        }
+        const snapshot = snapshotValues(fields);
+        const result = submitHandler ? await submitHandler(snapshot) : void 0;
+        return { valid: true, values: snapshot, result };
+      } finally {
+        submitting.value = false;
+      }
+    }, "run");
+    const pending = run().finally(() => {
+      submitPromise = null;
+    });
+    submitPromise = pending;
+    return pending;
+  }
+  __name(submit, "submit");
+  owner.onDispose(() => {
+    for (const field of fields.values()) cancelFieldValidation(field);
+    disposed = true;
+    fields.clear();
+    touchedNames.clear();
+    validatingNames.clear();
+  });
+  const api = {
+    values,
+    dirty,
+    touched,
+    errors,
+    hasErrors,
+    submitting,
+    validating,
+    validatingFields,
+    fieldNames,
+    Field: /* @__PURE__ */ __name((props) => Field({ ...props, form: api }), "Field"),
+    field: fieldApi,
+    addField,
+    removeField,
+    validateField,
+    validateAll,
+    setServerErrors,
+    clearErrors,
+    getErrorFields,
+    submit,
+    reset,
+    dispose() {
+      if (!disposed) owner.dispose();
+    }
+  };
+  return api;
+}
+__name(createForm, "createForm");
+function snapshotValues(fields) {
+  const snapshot = {};
+  for (const [name, field] of fields) snapshot[name] = field.value.value;
+  return snapshot;
+}
+__name(snapshotValues, "snapshotValues");
+function createValuesProxy(fields) {
+  return new Proxy({}, {
+    get(_target, property) {
+      if (typeof property !== "string") return void 0;
+      return fields.get(property)?.value.value;
+    },
+    set() {
+      throw new Error("Vobs forms: values \u4E0D\u80FD\u76F4\u63A5\u8D4B\u503C\uFF0C\u8BF7\u4F7F\u7528 field(name).set(value)");
+    },
+    has(_target, property) {
+      return typeof property === "string" && fields.has(property);
+    },
+    ownKeys() {
+      return [...fields.keys()];
+    },
+    getOwnPropertyDescriptor(_target, property) {
+      if (typeof property !== "string" || !fields.has(property)) return void 0;
+      return { enumerable: true, configurable: true };
+    }
+  });
+}
+__name(createValuesProxy, "createValuesProxy");
+function isPromiseLike(value) {
+  return Boolean(value) && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+__name(isPromiseLike, "isPromiseLike");
+function settle(value) {
+  return isPromiseLike(value) ? Promise.resolve(value).then(() => void 0) : Promise.resolve();
+}
+__name(settle, "settle");
+
+// packages/forms/src/rules.ts
+var rules = {
+  required(value) {
+    if (value === void 0 || value === null || value === "") return "\u5FC5\u586B";
+    return null;
+  },
+  email(value) {
+    if (value === void 0 || value === null || value === "") return null;
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value)) ? null : "\u90AE\u7BB1\u683C\u5F0F\u9519\u8BEF";
+  },
+  phone(value) {
+    if (value === void 0 || value === null || value === "") return null;
+    return /^1[3-9]\d{9}$/.test(String(value)) ? null : "\u624B\u673A\u53F7\u683C\u5F0F\u9519\u8BEF";
+  },
+  minLength(min) {
+    assertNonNegativeInteger(min, "minLength");
+    return (value) => value === void 0 || value === null || value.length >= min ? null : `\u81F3\u5C11 ${min} \u4E2A\u5B57\u7B26`;
+  },
+  maxLength(max) {
+    assertNonNegativeInteger(max, "maxLength");
+    return (value) => value === void 0 || value === null || value.length <= max ? null : `\u6700\u591A ${max} \u4E2A\u5B57\u7B26`;
+  },
+  min(minimum) {
+    assertFiniteNumber(minimum, "min");
+    return (value) => value === void 0 || value === null || value >= minimum ? null : `\u4E0D\u80FD\u5C0F\u4E8E ${minimum}`;
+  },
+  max(maximum) {
+    assertFiniteNumber(maximum, "max");
+    return (value) => value === void 0 || value === null || value <= maximum ? null : `\u4E0D\u80FD\u5927\u4E8E ${maximum}`;
+  },
+  pattern(pattern, message) {
+    return (value) => {
+      if (value === void 0 || value === null || value === "") return null;
+      pattern.lastIndex = 0;
+      return pattern.test(value) ? null : message;
+    };
+  }
+};
+function assertNonNegativeInteger(value, name) {
+  if (!Number.isInteger(value) || value < 0) throw new Error(`Vobs forms: ${name} \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6574\u6570`);
+}
+__name(assertNonNegativeInteger, "assertNonNegativeInteger");
+function assertFiniteNumber(value, name) {
+  if (!Number.isFinite(value)) throw new Error(`Vobs forms: ${name} \u5FC5\u987B\u662F\u6709\u9650\u6570\u5B57`);
+}
+__name(assertFiniteNumber, "assertFiniteNumber");
+
+// packages/forms/src/plugin.ts
+var FORMS_KEY = createInjectionKey("vobs.forms");
+function formsPlugin(options = {}) {
+  return {
+    name: "@vobs/forms",
+    version: "0.1.0",
+    install(context) {
+      context.provide(FORMS_KEY, options.client ?? { createForm });
+    }
+  };
+}
+__name(formsPlugin, "formsPlugin");
+
+exports.FORMS_KEY = FORMS_KEY;
+exports.Field = Field;
+exports.createForm = createForm;
+exports.formsPlugin = formsPlugin;
+exports.rules = rules;
+exports.useForm = useForm;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map