@formwright/core 0.2.0 → 0.2.2

package/dist/chunk-OWEG6VGP.js

@@ -0,0 +1,3 @@
+export { batch, computed, effect, isTracking, signal, untrack } from '@formwright/reactive';
+//# sourceMappingURL=chunk-OWEG6VGP.js.map
+//# sourceMappingURL=chunk-OWEG6VGP.js.map

package/dist/{chunk-O4DUMDBU.js.map → chunk-OWEG6VGP.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-O4DUMDBU.js","sourcesContent":[]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-OWEG6VGP.js","sourcesContent":[]}

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var reactive = require('@wright/reactive');
+var reactive = require('@formwright/reactive');
 var schema = require('@formwright/schema');
 
 // src/reactive.ts
@@ -187,9 +187,11 @@ var FieldState = class {
   revision;
   validator;
   rev = reactive.signal(0);
-  constructor(schema, initial, getValue) {
+  stepActive;
+  constructor(schema, initial, getValue, stepActive) {
     this.id = schema.id;
     this.schema = schema;
+    this.stepActive = stepActive;
     this.value = reactive.signal(initial);
     this.error = reactive.signal(null);
     this.touched = reactive.signal(false);
@@ -217,12 +219,16 @@ var FieldState = class {
     this.validator = this.schema.validation ? compileValidator(this.schema.validation) : null;
     this.rev.update((n) => n + 1);
   }
-  /** Run validation, store and return the error (or null). Hidden fields never error. */
-  validate() {
+  /** Run validation, store and return the error (or null). Hidden / inactive-step fields never error. */
+  validate(options) {
     if (!this.visible.peek()) {
       this.error.set(null);
       return null;
     }
+    if (!options?.allSteps && this.stepActive && !this.stepActive.peek()) {
+      this.error.set(null);
+      return null;
+    }
     let result = null;
     if (this.required.peek() && isEmpty2(this.value.peek())) {
       result = requiredMessage(this.schema.validation);
@@ -259,18 +265,24 @@ function collectValues(nodes) {
   }
   return out;
 }
-function buildNodes(schemas, scope, initial) {
+function buildNodes(schemas, scope, initial, stepActive) {
   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]));
+      node = new GroupNode(schema, scope, asDict(initial[schema.id]), stepActive);
+    } else if (schema.type === "step") {
+      if (!stepActive)
+        throw new Error('Field type "step" must be nested inside a "steps" container');
+      node = new StepNode(schema, scope, asDict(initial[schema.id]), stepActive);
     } else if (schema.type === "collection") {
       node = new CollectionNode(schema, scope, asArray(initial[schema.id]));
+    } else if (schema.type === "steps") {
+      node = new StepsNode(schema, scope, asDict(initial[schema.id]));
     } else {
       const init = initial[schema.id] ?? schema.defaultValue ?? defaultValueFor(schema.type);
-      node = new FieldState(schema, init, scope);
+      node = new FieldState(schema, init, scope, stepActive);
     }
     nodes.push(node);
     byName.set(schema.id, node);
@@ -288,7 +300,9 @@ function resetNodes(nodes, initial) {
     if (node.kind === "field") {
       const init = initial[node.id] ?? node.schema.defaultValue ?? defaultValueFor(node.schema.type);
       node.reset(init);
-    } else if (node.kind === "group") {
+    } else if (node.kind === "group" || node.kind === "step") {
+      node.reset(asDict(initial[node.id]));
+    } else if (node.kind === "steps") {
       node.reset(asDict(initial[node.id]));
     } else {
       node.reset(asArray(initial[node.id]));
@@ -306,14 +320,14 @@ var GroupNode = class {
   enabled;
   /** The scope a child uses: resolve a name among siblings, else delegate upward. */
   scope;
-  constructor(schema, parentScope, initial) {
+  constructor(schema, parentScope, initial, stepActive) {
     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);
+    const built = buildNodes(schema.fields ?? [], this.scope, initial, stepActive);
     this.children = built.nodes;
     this.byName = built.byName;
     this.value = reactive.computed(() => collectValues(this.children));
@@ -376,6 +390,109 @@ var CollectionNode = class {
     this.rows.set(this.seedRows(initial));
   }
 };
+var StepNode = class {
+  kind = "step";
+  id;
+  schema;
+  children;
+  byName;
+  value;
+  visible;
+  enabled;
+  scope;
+  /** True when this step is the active step in its parent wizard. */
+  active;
+  constructor(schema, parentScope, initial, active) {
+    this.id = schema.id;
+    this.schema = schema;
+    this.active = active;
+    this.scope = (name) => {
+      const child = this.byName.get(name);
+      return child ? nodeValue(child) : parentScope(name);
+    };
+    const built = buildNodes(schema.fields ?? [], this.scope, initial, active);
+    this.children = built.nodes;
+    this.byName = built.byName;
+    this.value = reactive.computed(() => collectValues(this.children));
+    this.visible = reactive.computed(() => evaluateCondition(schema.visibleWhen, parentScope, true));
+    this.enabled = reactive.computed(() => evaluateCondition(schema.enabledWhen, parentScope, true));
+  }
+  reset(initial) {
+    resetNodes(this.children, initial);
+  }
+};
+var StepsNode = class {
+  kind = "steps";
+  id;
+  schema;
+  steps;
+  byName;
+  value;
+  visible;
+  enabled;
+  currentStep;
+  scope;
+  constructor(schema, parentScope, initial) {
+    this.id = schema.id;
+    this.schema = schema;
+    this.currentStep = reactive.signal(0);
+    this.byName = /* @__PURE__ */ new Map();
+    this.scope = (name) => {
+      const step = this.byName.get(name);
+      return step ? step.value.get() : parentScope(name);
+    };
+    const stepSchemas = schema.fields ?? [];
+    const steps = stepSchemas.map((stepSchema, index) => {
+      const active = reactive.computed(() => this.currentStep.get() === index);
+      const stepInitial = asDict(initial[stepSchema.id]);
+      const step = new StepNode(stepSchema, this.scope, stepInitial, active);
+      this.byName.set(stepSchema.id, step);
+      return step;
+    });
+    this.steps = steps;
+    this.value = reactive.computed(() => {
+      const out = {};
+      for (const step of this.steps) out[step.id] = step.value.get();
+      return out;
+    });
+    this.visible = reactive.computed(() => evaluateCondition(schema.visibleWhen, parentScope, true));
+    this.enabled = reactive.computed(() => evaluateCondition(schema.enabledWhen, parentScope, true));
+  }
+  /** Validate every leaf in the step at `index` (defaults to the current step). */
+  validateStep(index) {
+    const i = index ?? this.currentStep.peek();
+    const step = this.steps[i];
+    if (!step) return true;
+    let ok = true;
+    eachLeaf([step], (leaf) => {
+      if (leaf.validate() !== null) ok = false;
+    });
+    return ok;
+  }
+  /** Advance to the next step after optionally validating the current one. Returns false if blocked. */
+  next() {
+    const validate = this.schema.validateOnNext !== false;
+    if (validate && !this.validateStep()) return false;
+    const cur = this.currentStep.peek();
+    if (cur < this.steps.length - 1) {
+      this.currentStep.set(cur + 1);
+      return true;
+    }
+    return false;
+  }
+  /** Go back one step (no validation). */
+  prev() {
+    this.currentStep.update((i) => Math.max(0, i - 1));
+  }
+  /** Jump to a step by index (does not validate). */
+  goTo(index) {
+    if (index >= 0 && index < this.steps.length) this.currentStep.set(index);
+  }
+  reset(initial) {
+    this.currentStep.set(0);
+    for (const step of this.steps) step.reset(asDict(initial[step.id]));
+  }
+};
 function buildTree(schemas, initial) {
   let byName;
   const scope = (name) => {
@@ -389,8 +506,10 @@ function buildTree(schemas, initial) {
 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);
+    else if (node.kind === "group" || node.kind === "step") eachLeaf(node.children, visit);
+    else if (node.kind === "steps") {
+      for (const step of node.steps) eachLeaf(step.children, visit);
+    } else for (const row of node.items.peek()) eachLeaf(row.group.children, visit);
   }
 }
 var defaultRenderer = null;
@@ -493,17 +612,22 @@ var Form = class {
   }
   // ---- lifecycle ----------------------------------------------------------
   /** Validate every (visible) leaf field; returns true when the whole form is valid. */
-  validate() {
+  validate(options) {
+    const allSteps = options?.allSteps ?? false;
     return reactive.untrack(() => {
       let ok = true;
       reactive.batch(() => {
         eachLeaf(this.tree, (leaf) => {
-          if (leaf.validate() !== null) ok = false;
+          if (leaf.validate({ allSteps }) !== null) ok = false;
         });
       });
       return ok;
     });
   }
+  /** Find the first `steps` container in the field tree (if any). */
+  findSteps() {
+    return findSteps(this.tree);
+  }
   /**
    * Run the submission pipeline: validate → transform → send → onSuccess/onError.
    * Pass an inline `transform` to shape the final payload, e.g.
@@ -514,7 +638,7 @@ var Form = class {
    * `const res = await form.submit(); res.ok ? res.data : res.error`.
    */
   async submit(transform) {
-    if (!this.validate()) {
+    if (!this.validate({ allSteps: true })) {
       const errors = this.collectErrors();
       const error = new FormValidationError(errors);
       this.runErrorHandler(error);
@@ -694,8 +818,10 @@ function collectLeaves(tree) {
     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 {
+      else if (node.kind === "group" || node.kind === "step") walk(node.children, path);
+      else if (node.kind === "steps") {
+        for (const step of node.steps) walk(step.children, `${path}.${step.id}`);
+      } else {
         node.items.peek().forEach((row, i) => walk(row.group.children, `${path}.${i}`));
       }
     }
@@ -708,7 +834,9 @@ function resolveLeaf(tree, rootByName, path) {
   let node = rootByName.get(parts[0]);
   for (let i = 1; i < parts.length && node; i++) {
     const part = parts[i];
-    if (node instanceof GroupNode) {
+    if (node instanceof GroupNode || node instanceof StepNode) {
+      node = node.byName.get(part);
+    } else if (node instanceof StepsNode) {
       node = node.byName.get(part);
     } else if (node instanceof CollectionNode) {
       node = node.items.peek()[Number(part)]?.group;
@@ -718,6 +846,21 @@ function resolveLeaf(tree, rootByName, path) {
   }
   return node && node.kind === "field" ? node : void 0;
 }
+function findSteps(tree) {
+  for (const node of tree) {
+    if (node.kind === "steps") return node;
+    if (node.kind === "group" || node.kind === "step") {
+      const found = findSteps(node.children);
+      if (found) return found;
+    } else if (node.kind === "collection") {
+      for (const row of node.items.peek()) {
+        const found = findSteps(row.group.children);
+        if (found) return found;
+      }
+    }
+  }
+  return void 0;
+}
 
 Object.defineProperty(exports, "batch", {
   enumerable: true,
@@ -748,6 +891,8 @@ exports.FieldState = FieldState;
 exports.Form = Form;
 exports.FormValidationError = FormValidationError;
 exports.GroupNode = GroupNode;
+exports.StepNode = StepNode;
+exports.StepsNode = StepsNode;
 exports.buildTree = buildTree;
 exports.compileValidator = compileValidator;
 exports.defaultValueFor = defaultValueFor;