@formwright/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,764 @@
+'use strict';
+
+var schema = require('@formwright/schema');
+
+// src/reactive.ts
+var activeObserver = null;
+var batchDepth = 0;
+var pendingEffects = /* @__PURE__ */ new Set();
+var flushing = false;
+function link(source) {
+  const obs = activeObserver;
+  if (obs === null) return;
+  if (!source.observers.has(obs)) {
+    source.observers.add(obs);
+    obs.sources.add(source);
+  }
+}
+function clearSources(obs) {
+  for (const src of obs.sources) src.observers.delete(obs);
+  obs.sources.clear();
+}
+function flush() {
+  if (flushing) return;
+  flushing = true;
+  try {
+    while (pendingEffects.size > 0) {
+      const next = pendingEffects.values().next().value;
+      pendingEffects.delete(next);
+      next.run();
+    }
+  } finally {
+    flushing = false;
+  }
+}
+var SignalNode = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  observers = /* @__PURE__ */ new Set();
+  get() {
+    link(this);
+    return this.value;
+  }
+  peek() {
+    return this.value;
+  }
+  set(next) {
+    if (Object.is(next, this.value)) return;
+    this.value = next;
+    for (const obs of [...this.observers]) obs.notify();
+    if (batchDepth === 0) flush();
+  }
+  update(fn) {
+    this.set(fn(this.value));
+  }
+};
+var ComputedNode = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  fn;
+  observers = /* @__PURE__ */ new Set();
+  sources = /* @__PURE__ */ new Set();
+  value;
+  dirty = true;
+  notify() {
+    if (this.dirty) return;
+    this.dirty = true;
+    for (const obs of [...this.observers]) obs.notify();
+  }
+  get() {
+    link(this);
+    if (this.dirty) this.recompute();
+    return this.value;
+  }
+  peek() {
+    if (this.dirty) this.recompute();
+    return this.value;
+  }
+  recompute() {
+    clearSources(this);
+    const prev = activeObserver;
+    activeObserver = this;
+    try {
+      this.value = this.fn();
+      this.dirty = false;
+    } finally {
+      activeObserver = prev;
+    }
+  }
+};
+var EffectNode = class {
+  constructor(fn) {
+    this.fn = fn;
+    this.run();
+  }
+  fn;
+  sources = /* @__PURE__ */ new Set();
+  cleanup = void 0;
+  disposed = false;
+  notify() {
+    if (this.disposed) return;
+    pendingEffects.add(this);
+  }
+  run() {
+    if (this.disposed) return;
+    this.runCleanup();
+    clearSources(this);
+    const prev = activeObserver;
+    activeObserver = this;
+    try {
+      this.cleanup = this.fn();
+    } finally {
+      activeObserver = prev;
+    }
+  }
+  runCleanup() {
+    if (typeof this.cleanup === "function") {
+      this.cleanup();
+      this.cleanup = void 0;
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.runCleanup();
+    clearSources(this);
+    pendingEffects.delete(this);
+  }
+};
+function signal(initial) {
+  return new SignalNode(initial);
+}
+function computed(fn) {
+  return new ComputedNode(fn);
+}
+function effect(fn) {
+  const node = new EffectNode(fn);
+  return () => node.dispose();
+}
+function untrack(fn) {
+  const prev = activeObserver;
+  activeObserver = null;
+  try {
+    return fn();
+  } finally {
+    activeObserver = prev;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) flush();
+  }
+}
+function isTracking() {
+  return activeObserver !== null;
+}
+
+// src/conditions.ts
+function isOp(cond, key) {
+  return typeof cond === "object" && cond !== null && key in cond;
+}
+function toNumber(v) {
+  return typeof v === "number" ? v : Number(v);
+}
+function evalNode(cond, get) {
+  if (cond === null || typeof cond !== "object") return cond;
+  if (Array.isArray(cond)) return cond;
+  if (isOp(cond, "var")) return get(String(cond.var));
+  if (isOp(cond, "==")) {
+    const [a, b] = cond["=="];
+    return evalNode(a, get) === evalNode(b, get);
+  }
+  if (isOp(cond, "!=")) {
+    const [a, b] = cond["!="];
+    return evalNode(a, get) !== evalNode(b, get);
+  }
+  if (isOp(cond, ">")) {
+    const [a, b] = cond[">"];
+    return toNumber(evalNode(a, get)) > toNumber(evalNode(b, get));
+  }
+  if (isOp(cond, ">=")) {
+    const [a, b] = cond[">="];
+    return toNumber(evalNode(a, get)) >= toNumber(evalNode(b, get));
+  }
+  if (isOp(cond, "<")) {
+    const [a, b] = cond["<"];
+    return toNumber(evalNode(a, get)) < toNumber(evalNode(b, get));
+  }
+  if (isOp(cond, "<=")) {
+    const [a, b] = cond["<="];
+    return toNumber(evalNode(a, get)) <= toNumber(evalNode(b, get));
+  }
+  if (isOp(cond, "in")) {
+    const [a, b] = cond["in"];
+    const needle = evalNode(a, get);
+    const haystack = evalNode(b, get);
+    if (Array.isArray(haystack)) return haystack.includes(needle);
+    if (typeof haystack === "string") return haystack.includes(String(needle));
+    return false;
+  }
+  if (isOp(cond, "not")) {
+    return !truthy(evalNode(cond.not, get));
+  }
+  if (isOp(cond, "and")) {
+    return cond.and.every((c) => truthy(evalNode(c, get)));
+  }
+  if (isOp(cond, "or")) {
+    return cond.or.some((c) => truthy(evalNode(c, get)));
+  }
+  return false;
+}
+function truthy(v) {
+  return Boolean(v);
+}
+function evaluateCondition(cond, get, fallback = true) {
+  if (cond === void 0) return fallback;
+  return truthy(evalNode(cond, get));
+}
+function referencedFields(cond) {
+  const ids = /* @__PURE__ */ new Set();
+  const walk = (c) => {
+    if (c === null || typeof c !== "object") return;
+    if (Array.isArray(c)) {
+      c.forEach(walk);
+      return;
+    }
+    const rec = c;
+    if ("var" in rec) {
+      ids.add(String(rec["var"]));
+      return;
+    }
+    for (const v of Object.values(rec)) walk(v);
+  };
+  if (cond !== void 0) walk(cond);
+  return [...ids];
+}
+
+// src/validation.ts
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var URL = /^https?:\/\/[^\s]+$/;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "";
+}
+function compileValidator(schema) {
+  return (value) => {
+    const msg = (fallback) => typeof schema.message === "string" ? schema.message : fallback;
+    if (isEmpty(value)) {
+      return schema.required ? msg("This field is required") : null;
+    }
+    if (schema.kind === "string" || schema.format) {
+      const str = String(value);
+      if (schema.minLength !== void 0 && str.length < schema.minLength) {
+        return msg(`Must be at least ${schema.minLength} characters`);
+      }
+      if (schema.maxLength !== void 0 && str.length > schema.maxLength) {
+        return msg(`Must be at most ${schema.maxLength} characters`);
+      }
+      if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(str)) {
+        return msg("Invalid format");
+      }
+      if (schema.format === "email" && !EMAIL.test(str)) return msg("Enter a valid email");
+      if (schema.format === "url" && !URL.test(str)) return msg("Enter a valid URL");
+      if (schema.format === "uuid" && !UUID.test(str)) return msg("Enter a valid UUID");
+    }
+    if (schema.kind === "number") {
+      const num = Number(value);
+      if (Number.isNaN(num)) return msg("Must be a number");
+      if (schema.min !== void 0 && num < schema.min) return msg(`Must be \u2265 ${schema.min}`);
+      if (schema.max !== void 0 && num > schema.max) return msg(`Must be \u2264 ${schema.max}`);
+    }
+    return null;
+  };
+}
+
+// src/providers.ts
+function isProviderRef(value) {
+  return typeof value === "object" && value !== null && ("$t" in value || "$query" in value || "$theme" in value);
+}
+function resolve(value, providers) {
+  if (value === void 0) return void 0;
+  if (!isProviderRef(value)) return value;
+  if ("$t" in value) {
+    const i18n = providers?.i18n;
+    return i18n ? i18n.t(value.$t, value.args) : value.$t;
+  }
+  if ("$theme" in value) {
+    const theme = providers?.theme;
+    return theme ? theme.token(value.$theme) : value.$theme;
+  }
+  return void 0;
+}
+function resolveQuery(value, providers) {
+  if (!isProviderRef(value) || !("$query" in value)) return null;
+  const provider = providers?.query;
+  if (!provider) return null;
+  const spec = value.$query;
+  if (typeof spec === "string") return provider.query(spec);
+  const [key, params] = spec;
+  return provider.query(key, params);
+}
+
+// src/model.ts
+function defaultValueFor(type) {
+  switch (type) {
+    case "checkbox":
+      return false;
+    case "number":
+      return void 0;
+    default:
+      return "";
+  }
+}
+var FieldState = class {
+  /** Discriminant for the {@link FieldNode} union (leaf vs group/collection). */
+  kind = "field";
+  id;
+  schema;
+  value;
+  error;
+  touched;
+  visible;
+  enabled;
+  required;
+  validator;
+  constructor(schema, initial, getValue) {
+    this.id = schema.id;
+    this.schema = schema;
+    this.value = signal(initial);
+    this.error = signal(null);
+    this.touched = signal(false);
+    this.validator = schema.validation ? compileValidator(schema.validation) : null;
+    this.visible = computed(() => evaluateCondition(schema.visibleWhen, getValue, true));
+    this.enabled = computed(() => evaluateCondition(schema.enabledWhen, getValue, true));
+    this.required = computed(() => {
+      if (schema.requiredWhen !== void 0) {
+        return evaluateCondition(schema.requiredWhen, getValue, false);
+      }
+      return schema.validation?.required ?? false;
+    });
+  }
+  /** Run validation, store and return the error (or null). Hidden fields never error. */
+  validate() {
+    if (!this.visible.peek()) {
+      this.error.set(null);
+      return null;
+    }
+    let result = null;
+    if (this.required.peek() && isEmpty2(this.value.peek())) {
+      result = "This field is required";
+    } else if (this.validator) {
+      result = this.validator(this.value.peek());
+    }
+    this.error.set(result);
+    return result;
+  }
+  reset(value) {
+    this.value.set(value);
+    this.error.set(null);
+    this.touched.set(false);
+  }
+};
+function isEmpty2(value) {
+  return value === void 0 || value === null || value === "";
+}
+
+// src/nodes.ts
+function nodeValue(node) {
+  return node.value.get();
+}
+function collectValues(nodes) {
+  const out = {};
+  for (const node of nodes) out[node.id] = nodeValue(node);
+  return out;
+}
+function buildNodes(schemas, scope, initial) {
+  const nodes = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    let node;
+    if (schema.type === "group") {
+      node = new GroupNode(schema, scope, asDict(initial[schema.id]));
+    } else if (schema.type === "collection") {
+      node = new CollectionNode(schema, scope, asArray(initial[schema.id]));
+    } else {
+      const init = initial[schema.id] ?? schema.defaultValue ?? defaultValueFor(schema.type);
+      node = new FieldState(schema, init, scope);
+    }
+    nodes.push(node);
+    byName.set(schema.id, node);
+  }
+  return { nodes, byName };
+}
+function asDict(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
+}
+function resetNodes(nodes, initial) {
+  for (const node of nodes) {
+    if (node.kind === "field") {
+      const init = initial[node.id] ?? node.schema.defaultValue ?? defaultValueFor(node.schema.type);
+      node.reset(init);
+    } else if (node.kind === "group") {
+      node.reset(asDict(initial[node.id]));
+    } else {
+      node.reset(asArray(initial[node.id]));
+    }
+  }
+}
+var GroupNode = class {
+  kind = "group";
+  id;
+  schema;
+  children;
+  byName;
+  value;
+  visible;
+  enabled;
+  /** The scope a child uses: resolve a name among siblings, else delegate upward. */
+  scope;
+  constructor(schema, parentScope, initial) {
+    this.id = schema.id;
+    this.schema = schema;
+    this.scope = (name) => {
+      const child = this.byName.get(name);
+      return child ? nodeValue(child) : parentScope(name);
+    };
+    const built = buildNodes(schema.fields ?? [], this.scope, initial);
+    this.children = built.nodes;
+    this.byName = built.byName;
+    this.value = computed(() => collectValues(this.children));
+    this.visible = computed(() => evaluateCondition(schema.visibleWhen, parentScope, true));
+    this.enabled = computed(() => evaluateCondition(schema.enabledWhen, parentScope, true));
+  }
+  reset(initial) {
+    resetNodes(this.children, initial);
+  }
+};
+var CollectionNode = class {
+  kind = "collection";
+  id;
+  schema;
+  value;
+  visible;
+  enabled;
+  rows;
+  parentScope;
+  itemSchema;
+  seq = 0;
+  constructor(schema, parentScope, initial) {
+    this.id = schema.id;
+    this.schema = schema;
+    this.parentScope = parentScope;
+    this.itemSchema = { id: schema.id, type: "group", fields: schema.fields ?? [] };
+    const seed = this.seedRows(initial);
+    this.rows = signal(seed);
+    this.value = computed(() => this.rows.get().map((row) => row.group.value.get()));
+    this.visible = computed(() => evaluateCondition(schema.visibleWhen, parentScope, true));
+    this.enabled = computed(() => evaluateCondition(schema.enabledWhen, parentScope, true));
+  }
+  /** Reactive list of rows (subscribes the caller to add/remove). */
+  get items() {
+    return this.rows;
+  }
+  makeItem(initial) {
+    return { key: this.seq++, group: new GroupNode(this.itemSchema, this.parentScope, initial) };
+  }
+  seedRows(initial) {
+    const rows = initial.map((row) => this.makeItem(row));
+    const min = this.schema.minItems ?? 0;
+    while (rows.length < min) rows.push(this.makeItem({}));
+    return rows;
+  }
+  /** Append a new empty row, unless `maxItems` is reached. */
+  add() {
+    const max = this.schema.maxItems;
+    if (max !== void 0 && this.rows.peek().length >= max) return;
+    this.rows.update((rows) => [...rows, this.makeItem({})]);
+  }
+  /** Remove the row at `index`, unless `minItems` would be violated. */
+  removeAt(index) {
+    const min = this.schema.minItems ?? 0;
+    if (this.rows.peek().length <= min) return;
+    this.rows.update((rows) => rows.filter((_, i) => i !== index));
+  }
+  reset(initial) {
+    this.seq = 0;
+    this.rows.set(this.seedRows(initial));
+  }
+};
+function buildTree(schemas, initial) {
+  let byName;
+  const scope = (name) => {
+    const node = byName.get(name);
+    return node ? nodeValue(node) : void 0;
+  };
+  const built = buildNodes(schemas, scope, initial);
+  byName = built.byName;
+  return { nodes: built.nodes, byName, scope };
+}
+function eachLeaf(nodes, visit) {
+  for (const node of nodes) {
+    if (node.kind === "field") visit(node);
+    else if (node.kind === "group") eachLeaf(node.children, visit);
+    else for (const row of node.items.peek()) eachLeaf(row.group.children, visit);
+  }
+}
+var defaultRenderer = null;
+function setDefaultRenderer(renderer) {
+  defaultRenderer = renderer;
+}
+var Form = class {
+  schema;
+  options;
+  /** Top-level field tree (leaf fields, groups, and collections, in order). */
+  tree;
+  order;
+  /** Reactive snapshot of all field values (nested for groups/collections). */
+  values;
+  /** True when the current values differ from the initial values. */
+  isDirty;
+  /** True when no visible field currently has an error. */
+  isValid;
+  submitting = signal(false);
+  initialValues;
+  initialSnapshot;
+  rootByName;
+  listeners = /* @__PURE__ */ new Map();
+  disposeRenderer = null;
+  constructor(schema$1, initialValues = {}, options = {}) {
+    this.schema = schema.parseSchema(schema$1);
+    this.options = options;
+    this.initialValues = initialValues;
+    const tree = buildTree(this.schema.fields, initialValues);
+    this.tree = tree.nodes;
+    this.rootByName = tree.byName;
+    this.order = this.schema.fields.map((f) => f.id);
+    this.values = computed(() => collectTree(this.tree));
+    this.initialSnapshot = JSON.stringify(untrack(() => this.values.peek()));
+    this.isDirty = computed(() => JSON.stringify(this.values.get()) !== this.initialSnapshot);
+    this.isValid = computed(() => {
+      let valid = true;
+      eachLeaf(this.tree, (leaf) => {
+        if (leaf.visible.get() && leaf.error.get() !== null) valid = false;
+      });
+      return valid;
+    });
+  }
+  // ---- value access -------------------------------------------------------
+  /** All leaf fields keyed by dotted path (e.g. `items.name`, `contacts.0.email`). */
+  get fields() {
+    return collectLeaves(this.tree);
+  }
+  /** Resolve a leaf field by dotted path. Top-level ids work directly. */
+  field(path) {
+    return resolveLeaf(this.tree, this.rootByName, path);
+  }
+  getValue(path) {
+    return this.field(path)?.value.peek();
+  }
+  setValue(path, value) {
+    const field = this.field(path);
+    if (field) this.setFieldValue(field, value);
+  }
+  /** Apply a value to a specific leaf node (used by the renderer). */
+  setFieldValue(field, value) {
+    field.value.set(value);
+    field.touched.set(true);
+    if (field.error.peek() !== null) field.validate();
+    this.emit("change", { id: field.id, value });
+  }
+  setError(id, error) {
+    this.field(id)?.error.set(error);
+  }
+  setErrors(errors) {
+    batch(() => {
+      for (const [id, error] of Object.entries(errors)) this.setError(id, error);
+    });
+  }
+  get isSubmitting() {
+    return this.submitting;
+  }
+  // ---- lifecycle ----------------------------------------------------------
+  /** Validate every (visible) leaf field; returns true when the whole form is valid. */
+  validate() {
+    return untrack(() => {
+      let ok = true;
+      batch(() => {
+        eachLeaf(this.tree, (leaf) => {
+          if (leaf.validate() !== null) ok = false;
+        });
+      });
+      return ok;
+    });
+  }
+  /** Run the submission pipeline: validate → transform → send → onSuccess/onError. */
+  async submit() {
+    if (!this.validate()) {
+      const error = new FormValidationError(this.collectErrors());
+      this.runErrorHandler(error);
+      this.emit("error", error);
+      throw error;
+    }
+    this.submitting.set(true);
+    const values = untrack(() => this.values.peek());
+    const payload = this.applyTransform(values);
+    this.emit("submit", payload);
+    try {
+      const result = await this.send(payload);
+      this.runSuccessHandler(result);
+      this.emit("success", result);
+      return result;
+    } catch (error) {
+      this.runErrorHandler(error);
+      this.emit("error", error);
+      throw error;
+    } finally {
+      this.submitting.set(false);
+    }
+  }
+  reset(values = this.initialValues) {
+    batch(() => {
+      resetNodes(this.tree, values);
+    });
+  }
+  /** Mount into a host element using the given renderer (or the registered default). */
+  mount(host, renderer = defaultRenderer) {
+    if (!renderer) {
+      throw new Error(
+        "No renderer available. Import '@formwright/dom' or pass a renderer to Form.mount()."
+      );
+    }
+    this.disposeRenderer?.();
+    this.disposeRenderer = renderer.mount(this, host);
+    return this.disposeRenderer;
+  }
+  destroy() {
+    this.disposeRenderer?.();
+    this.disposeRenderer = null;
+    this.listeners.clear();
+  }
+  // ---- events -------------------------------------------------------------
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => set.delete(listener);
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (set) for (const listener of [...set]) listener(payload);
+  }
+  // ---- internals ----------------------------------------------------------
+  collectErrors() {
+    const errors = {};
+    for (const [path, field] of this.fields) errors[path] = field.error.peek();
+    return errors;
+  }
+  applyTransform(values) {
+    const name = this.schema.submit?.transform;
+    const transform = name ? this.options.transforms?.[name] : void 0;
+    return transform ? transform(values, this) : values;
+  }
+  async send(payload) {
+    if (this.options.send) return this.options.send(payload, this);
+    const endpoint = this.schema.submit?.endpoint;
+    if (!endpoint) return payload;
+    const init = {
+      method: endpoint.method,
+      headers: { "content-type": "application/json" }
+    };
+    if (endpoint.method !== "GET") init.body = JSON.stringify(payload);
+    const response = await fetch(endpoint.url, init);
+    if (!response.ok) throw new Error(`Request failed: ${response.status}`);
+    const text = await response.text();
+    return text ? JSON.parse(text) : void 0;
+  }
+  runSuccessHandler(result) {
+    const name = this.schema.submit?.onSuccess;
+    const handler = name ? this.options.handlers?.[name] : void 0;
+    handler?.(result, this);
+  }
+  runErrorHandler(error) {
+    const name = this.schema.submit?.onError;
+    const handler = name ? this.options.handlers?.[name] : void 0;
+    handler?.(error, this);
+  }
+};
+var FormValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super("Form validation failed");
+    this.name = "FormValidationError";
+    this.errors = errors;
+  }
+};
+function collectTree(tree) {
+  return collectValues(tree);
+}
+function collectLeaves(tree) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (nodes, prefix) => {
+    for (const node of nodes) {
+      const path = prefix ? `${prefix}.${node.id}` : node.id;
+      if (node.kind === "field") out.set(path, node);
+      else if (node.kind === "group") walk(node.children, path);
+      else {
+        node.items.peek().forEach((row, i) => walk(row.group.children, `${path}.${i}`));
+      }
+    }
+  };
+  walk(tree, "");
+  return out;
+}
+function resolveLeaf(tree, rootByName, path) {
+  const parts = path.split(".");
+  let node = rootByName.get(parts[0]);
+  for (let i = 1; i < parts.length && node; i++) {
+    const part = parts[i];
+    if (node instanceof GroupNode) {
+      node = node.byName.get(part);
+    } else if (node instanceof CollectionNode) {
+      node = node.items.peek()[Number(part)]?.group;
+    } else {
+      return void 0;
+    }
+  }
+  return node && node.kind === "field" ? node : void 0;
+}
+
+exports.CollectionNode = CollectionNode;
+exports.FieldState = FieldState;
+exports.Form = Form;
+exports.FormValidationError = FormValidationError;
+exports.GroupNode = GroupNode;
+exports.batch = batch;
+exports.buildTree = buildTree;
+exports.compileValidator = compileValidator;
+exports.computed = computed;
+exports.defaultValueFor = defaultValueFor;
+exports.eachLeaf = eachLeaf;
+exports.effect = effect;
+exports.evaluateCondition = evaluateCondition;
+exports.isProviderRef = isProviderRef;
+exports.isTracking = isTracking;
+exports.referencedFields = referencedFields;
+exports.resolve = resolve;
+exports.resolveQuery = resolveQuery;
+exports.setDefaultRenderer = setDefaultRenderer;
+exports.signal = signal;
+exports.untrack = untrack;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map