@waypointjs/core 0.1.5 → 0.1.6

package/dist/index.cjs

@@ -5,11 +5,15 @@ var middleware = require('zustand/middleware');
 var zod = require('zod');
 
 // src/conditions.ts
-function resolveFieldValue(path, data, externalVars) {
+function resolveFieldValue(path, data, externalVars, skippedSteps) {
   if (path.startsWith("$ext.")) {
     const varId = path.slice(5);
     return externalVars[varId];
   }
+  if (path.startsWith("$step.") && path.endsWith(".skipped")) {
+    const stepId2 = path.slice(6, -8);
+    return skippedSteps?.includes(stepId2) ?? false;
+  }
   const dotIndex = path.indexOf(".");
   if (dotIndex === -1) return void 0;
   const stepId = path.slice(0, dotIndex);
@@ -65,8 +69,8 @@ function evaluateOperator(operator, actual, expected) {
       return false;
   }
 }
-function evaluateRule(rule, data, externalVars, externalEnums) {
-  const actual = resolveFieldValue(rule.field, data, externalVars);
+function evaluateRule(rule, data, externalVars, externalEnums, skippedSteps) {
+  const actual = resolveFieldValue(rule.field, data, externalVars, skippedSteps);
   if ((rule.operator === "inEnum" || rule.operator === "notInEnum") && externalEnums) {
     const enumDef = externalEnums.find((e) => e.id === String(rule.value));
     const values = enumDef?.values.map((v) => String(v.value)) ?? [];
@@ -74,20 +78,20 @@ function evaluateRule(rule, data, externalVars, externalEnums) {
   }
   return evaluateOperator(rule.operator, actual, rule.value);
 }
-function evaluateConditionGroup(group, data, externalVars, externalEnums) {
+function evaluateConditionGroup(group, data, externalVars, externalEnums, skippedSteps) {
   const ruleResults = group.rules.map(
-    (rule) => evaluateRule(rule, data, externalVars, externalEnums)
+    (rule) => evaluateRule(rule, data, externalVars, externalEnums, skippedSteps)
   );
   const groupResults = (group.groups ?? []).map(
-    (subGroup) => evaluateConditionGroup(subGroup, data, externalVars, externalEnums)
+    (subGroup) => evaluateConditionGroup(subGroup, data, externalVars, externalEnums, skippedSteps)
   );
   const allResults = [...ruleResults, ...groupResults];
   if (allResults.length === 0) return true;
   return group.combinator === "and" ? allResults.every(Boolean) : allResults.some(Boolean);
 }
-function isVisible(visibleWhen, data, externalVars, externalEnums) {
+function isVisible(visibleWhen, data, externalVars, externalEnums, skippedSteps) {
   if (!visibleWhen) return true;
-  return evaluateConditionGroup(visibleWhen, data, externalVars, externalEnums);
+  return evaluateConditionGroup(visibleWhen, data, externalVars, externalEnums, skippedSteps);
 }
 
 // src/tree-resolver.ts
@@ -111,22 +115,32 @@ function findMissingBlockingVars(externalVariables, externalVars, visibleSteps)
     return value === void 0 || value === null;
   }).map((extVar) => extVar.id);
 }
-function resolveTree(schema, data, externalVars, externalEnums) {
+function resolveTree(schema, data, externalVars, externalEnums, skippedSteps) {
   const visibleSteps = [];
   const hiddenSteps = [];
   for (const stepDef of schema.steps) {
-    const stepVisible = isVisible(stepDef.visibleWhen, data, externalVars, externalEnums);
+    const stepVisible = isVisible(stepDef.visibleWhen, data, externalVars, externalEnums, skippedSteps);
     const resolvedFields = stepDef.fields.map((fieldDef) => {
       let resolvedOptions;
       if (fieldDef.externalEnumId && externalEnums) {
         const enumDef = externalEnums.find((e) => e.id === fieldDef.externalEnumId);
         resolvedOptions = enumDef?.values;
       }
+      let resolvedDefaultValue;
+      if (fieldDef.dynamicDefault && fieldDef.dynamicDefault.length > 0) {
+        for (const rule of fieldDef.dynamicDefault) {
+          if (evaluateConditionGroup(rule.when, data, externalVars, externalEnums, skippedSteps)) {
+            resolvedDefaultValue = rule.value;
+            break;
+          }
+        }
+      }
       return {
         definition: fieldDef,
-        visible: isVisible(fieldDef.visibleWhen, data, externalVars, externalEnums),
+        visible: isVisible(fieldDef.visibleWhen, data, externalVars, externalEnums, skippedSteps),
         dependenciesMet: areDependenciesMet(fieldDef.dependsOn, data, externalVars),
-        resolvedOptions
+        resolvedOptions,
+        resolvedDefaultValue
       };
     });
     const resolvedStep = {
@@ -193,7 +207,7 @@ function getResolvedTree(state) {
   if (!state.schema) {
     return { steps: [], hiddenSteps: [], missingExternalVars: [] };
   }
-  return resolveTree(state.schema, state.data, state.externalVars);
+  return resolveTree(state.schema, state.data, state.externalVars, void 0, state.skippedSteps);
 }
 function getCurrentStep(state) {
   if (!state.currentStepId) return void 0;
@@ -225,6 +239,7 @@ var initialState = {
   externalVars: {},
   currentStepId: null,
   history: [],
+  skippedSteps: [],
   isSubmitting: false,
   completed: false
 };
@@ -240,6 +255,7 @@ function buildStateCreator() {
         externalVars,
         currentStepId: firstStepId,
         history: firstStepId ? [firstStepId] : [],
+        skippedSteps: [],
         isSubmitting: false,
         completed: false
       });
@@ -281,6 +297,16 @@ function buildStateCreator() {
     setCompleted(b) {
       set({ completed: b });
     },
+    skipStep(stepId) {
+      set((state) => ({
+        skippedSteps: state.skippedSteps.includes(stepId) ? state.skippedSteps : [...state.skippedSteps, stepId]
+      }));
+    },
+    unskipStep(stepId) {
+      set((state) => ({
+        skippedSteps: state.skippedSteps.filter((id) => id !== stepId)
+      }));
+    },
     truncateHistoryAt(stepId) {
       set((state) => {
         const idx = state.history.indexOf(stepId);
@@ -319,6 +345,7 @@ function createRuntimeStore(options = {}) {
           data: state.data,
           currentStepId: state.currentStepId,
           history: state.history,
+          skippedSteps: state.skippedSteps,
           completed: state.completed
         })
       })
@@ -335,7 +362,13 @@ var customValidatorRegistry = {};
 function registerCustomValidator(id, fn) {
   customValidatorRegistry[id] = fn;
 }
-function buildFieldSchema(field, externalEnums) {
+function resolveRuleValue(rule, data) {
+  if (rule.refField && data) {
+    return resolveFieldValue(rule.refField, data, {});
+  }
+  return rule.value;
+}
+function buildFieldSchema(field, externalEnums, data) {
   const rules = field.validation ?? [];
   const isRequired = rules.some((r) => r.type === "required");
   const isNumeric = field.type === "number";
@@ -353,28 +386,47 @@ function buildFieldSchema(field, externalEnums) {
     let numSchema = zod.z.coerce.number({
       invalid_type_error: "Must be a number"
     });
+    const numRefineRules = [];
     for (const rule of rules) {
+      const rv = resolveRuleValue(rule, data);
+      const isRef = !!rule.refField;
       if (rule.type === "min" || rule.type === "greaterThanOrEqual") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.gte(n, rule.message);
+        const n = Number(rv);
+        if (!isNaN(n)) {
+          if (isRef) numRefineRules.push({ fn: (v) => v >= n, message: rule.message });
+          else numSchema = numSchema.gte(n, rule.message);
+        }
       } else if (rule.type === "max" || rule.type === "lessThanOrEqual") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.lte(n, rule.message);
+        const n = Number(rv);
+        if (!isNaN(n)) {
+          if (isRef) numRefineRules.push({ fn: (v) => v <= n, message: rule.message });
+          else numSchema = numSchema.lte(n, rule.message);
+        }
       } else if (rule.type === "greaterThan") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.gt(n, rule.message);
+        const n = Number(rv);
+        if (!isNaN(n)) {
+          if (isRef) numRefineRules.push({ fn: (v) => v > n, message: rule.message });
+          else numSchema = numSchema.gt(n, rule.message);
+        }
       } else if (rule.type === "lessThan") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.lt(n, rule.message);
+        const n = Number(rv);
+        if (!isNaN(n)) {
+          if (isRef) numRefineRules.push({ fn: (v) => v < n, message: rule.message });
+          else numSchema = numSchema.lt(n, rule.message);
+        }
       } else if (rule.type === "equals") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.refine((v) => v === n, rule.message);
+        const n = Number(rv);
+        if (!isNaN(n)) numRefineRules.push({ fn: (v) => v === n, message: rule.message });
       } else if (rule.type === "notEquals") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.refine((v) => v !== n, rule.message);
+        const n = Number(rv);
+        if (!isNaN(n)) numRefineRules.push({ fn: (v) => v !== n, message: rule.message });
       }
     }
-    return isRequired ? numSchema : numSchema.optional();
+    let numFinal = isRequired ? numSchema : numSchema.optional();
+    for (const { fn, message } of numRefineRules) {
+      numFinal = numFinal.refine((v) => v == null || fn(v), message);
+    }
+    return numFinal;
   }
   let strSchema = zod.z.string();
   const refineRules = [];
@@ -404,54 +456,70 @@ function buildFieldSchema(field, externalEnums) {
           strSchema = strSchema.regex(new RegExp(String(rule.value)), rule.message);
         }
         break;
-      case "equals":
-        if (rule.value !== void 0) {
-          const eq = String(rule.value);
+      case "equals": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const eq = String(rv);
           refineRules.push({ fn: (v) => String(v) === eq, message: rule.message });
         }
         break;
-      case "notEquals":
-        if (rule.value !== void 0) {
-          const neq = String(rule.value);
+      }
+      case "notEquals": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const neq = String(rv);
           refineRules.push({ fn: (v) => String(v) !== neq, message: rule.message });
         }
         break;
-      case "greaterThan":
-        if (rule.value !== void 0) {
-          const gt = Number(rule.value);
+      }
+      case "greaterThan": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const gt = Number(rv);
           refineRules.push({ fn: (v) => Number(v) > gt, message: rule.message });
         }
         break;
-      case "greaterThanOrEqual":
-        if (rule.value !== void 0) {
-          const gte = Number(rule.value);
+      }
+      case "greaterThanOrEqual": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const gte = Number(rv);
           refineRules.push({ fn: (v) => Number(v) >= gte, message: rule.message });
         }
         break;
-      case "lessThan":
-        if (rule.value !== void 0) {
-          const lt = Number(rule.value);
+      }
+      case "lessThan": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const lt = Number(rv);
           refineRules.push({ fn: (v) => Number(v) < lt, message: rule.message });
         }
         break;
-      case "lessThanOrEqual":
-        if (rule.value !== void 0) {
-          const lte = Number(rule.value);
+      }
+      case "lessThanOrEqual": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const lte = Number(rv);
           refineRules.push({ fn: (v) => Number(v) <= lte, message: rule.message });
         }
         break;
-      case "contains":
-        if (rule.value !== void 0) {
-          const sub = String(rule.value);
+      }
+      case "contains": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const sub = String(rv);
           refineRules.push({ fn: (v) => String(v).includes(sub), message: rule.message });
         }
         break;
-      case "notContains":
-        if (rule.value !== void 0) {
-          const nsub = String(rule.value);
+      }
+      case "notContains": {
+        const rv = resolveRuleValue(rule, data);
+        if (rv !== void 0) {
+          const nsub = String(rv);
           refineRules.push({ fn: (v) => !String(v).includes(nsub), message: rule.message });
         }
         break;
+      }
       case "matches":
         if (rule.value !== void 0 && rule.value !== null) {
           const rx = new RegExp(String(rule.value));
@@ -489,11 +557,11 @@ function buildFieldSchema(field, externalEnums) {
   }
   return finalSchema;
 }
-function buildZodSchema(fields, externalEnums) {
+function buildZodSchema(fields, externalEnums, data) {
   const shape = {};
   for (const resolvedField of fields) {
     if (!resolvedField.visible) continue;
-    shape[resolvedField.definition.id] = buildFieldSchema(resolvedField.definition, externalEnums);
+    shape[resolvedField.definition.id] = buildFieldSchema(resolvedField.definition, externalEnums, data);
   }
   return zod.z.object(shape);
 }