@waypointjs/core 0.1.4 → 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,24 +69,29 @@ function evaluateOperator(operator, actual, expected) {
       return false;
   }
 }
-function evaluateRule(rule, data, externalVars) {
-  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)) ?? [];
+    return rule.operator === "inEnum" ? values.includes(String(actual)) : !values.includes(String(actual));
+  }
   return evaluateOperator(rule.operator, actual, rule.value);
 }
-function evaluateConditionGroup(group, data, externalVars) {
+function evaluateConditionGroup(group, data, externalVars, externalEnums, skippedSteps) {
   const ruleResults = group.rules.map(
-    (rule) => evaluateRule(rule, data, externalVars)
+    (rule) => evaluateRule(rule, data, externalVars, externalEnums, skippedSteps)
   );
   const groupResults = (group.groups ?? []).map(
-    (subGroup) => evaluateConditionGroup(subGroup, data, externalVars)
+    (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) {
+function isVisible(visibleWhen, data, externalVars, externalEnums, skippedSteps) {
   if (!visibleWhen) return true;
-  return evaluateConditionGroup(visibleWhen, data, externalVars);
+  return evaluateConditionGroup(visibleWhen, data, externalVars, externalEnums, skippedSteps);
 }
 
 // src/tree-resolver.ts
@@ -106,16 +115,34 @@ function findMissingBlockingVars(externalVariables, externalVars, visibleSteps)
     return value === void 0 || value === null;
   }).map((extVar) => extVar.id);
 }
-function resolveTree(schema, data, externalVars) {
+function resolveTree(schema, data, externalVars, externalEnums, skippedSteps) {
   const visibleSteps = [];
   const hiddenSteps = [];
   for (const stepDef of schema.steps) {
-    const stepVisible = isVisible(stepDef.visibleWhen, data, externalVars);
-    const resolvedFields = stepDef.fields.map((fieldDef) => ({
-      definition: fieldDef,
-      visible: isVisible(fieldDef.visibleWhen, data, externalVars),
-      dependenciesMet: areDependenciesMet(fieldDef.dependsOn, data, externalVars)
-    }));
+    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, skippedSteps),
+        dependenciesMet: areDependenciesMet(fieldDef.dependsOn, data, externalVars),
+        resolvedOptions,
+        resolvedDefaultValue
+      };
+    });
     const resolvedStep = {
       definition: stepDef,
       visible: stepVisible,
@@ -180,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;
@@ -212,6 +239,7 @@ var initialState = {
   externalVars: {},
   currentStepId: null,
   history: [],
+  skippedSteps: [],
   isSubmitting: false,
   completed: false
 };
@@ -227,6 +255,7 @@ function buildStateCreator() {
         externalVars,
         currentStepId: firstStepId,
         history: firstStepId ? [firstStepId] : [],
+        skippedSteps: [],
         isSubmitting: false,
         completed: false
       });
@@ -268,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);
@@ -306,6 +345,7 @@ function createRuntimeStore(options = {}) {
           data: state.data,
           currentStepId: state.currentStepId,
           history: state.history,
+          skippedSteps: state.skippedSteps,
           completed: state.completed
         })
       })
@@ -322,7 +362,13 @@ var customValidatorRegistry = {};
 function registerCustomValidator(id, fn) {
   customValidatorRegistry[id] = fn;
 }
-function buildFieldSchema(field) {
+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";
@@ -340,16 +386,47 @@ function buildFieldSchema(field) {
     let numSchema = zod.z.coerce.number({
       invalid_type_error: "Must be a number"
     });
+    const numRefineRules = [];
     for (const rule of rules) {
-      if (rule.type === "min") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.gte(n, rule.message);
-      } else if (rule.type === "max") {
-        const n = Number(rule.value);
-        if (!isNaN(n)) numSchema = numSchema.lte(n, rule.message);
+      const rv = resolveRuleValue(rule, data);
+      const isRef = !!rule.refField;
+      if (rule.type === "min" || rule.type === "greaterThanOrEqual") {
+        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(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(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(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(rv);
+        if (!isNaN(n)) numRefineRules.push({ fn: (v) => v === n, message: rule.message });
+      } else if (rule.type === "notEquals") {
+        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 = [];
@@ -379,27 +456,112 @@ function buildFieldSchema(field) {
           strSchema = strSchema.regex(new RegExp(String(rule.value)), rule.message);
         }
         break;
+      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": {
+        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": {
+        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": {
+        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": {
+        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": {
+        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": {
+        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": {
+        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));
+          refineRules.push({ fn: (v) => rx.test(String(v)), message: rule.message });
+        }
+        break;
+      case "inEnum":
+        if (rule.value && externalEnums) {
+          const enumDef = externalEnums.find((e) => e.id === String(rule.value));
+          if (enumDef) {
+            const values = enumDef.values.map((v) => String(v.value));
+            refineRules.push({ fn: (v) => values.includes(String(v)), message: rule.message });
+          }
+        }
+        break;
+      case "notInEnum":
+        if (rule.value && externalEnums) {
+          const enumDef = externalEnums.find((e) => e.id === String(rule.value));
+          if (enumDef) {
+            const values = enumDef.values.map((v) => String(v.value));
+            refineRules.push({ fn: (v) => !values.includes(String(v)), message: rule.message });
+          }
+        }
+        break;
       case "custom":
         if (rule.customValidatorId && customValidatorRegistry[rule.customValidatorId]) {
-          refineRules.push({ id: rule.customValidatorId, message: rule.message });
+          refineRules.push({ fn: (v) => Boolean(customValidatorRegistry[rule.customValidatorId]?.(v)), message: rule.message });
         }
         break;
     }
   }
   let finalSchema = isRequired ? strSchema : strSchema.optional();
-  for (const { id, message } of refineRules) {
-    finalSchema = finalSchema.refine(
-      (val) => Boolean(customValidatorRegistry[id]?.(val)),
-      message
-    );
+  for (const { fn, message } of refineRules) {
+    finalSchema = finalSchema.refine(fn, message);
   }
   return finalSchema;
 }
-function buildZodSchema(fields) {
+function buildZodSchema(fields, externalEnums, data) {
   const shape = {};
   for (const resolvedField of fields) {
     if (!resolvedField.visible) continue;
-    shape[resolvedField.definition.id] = buildFieldSchema(resolvedField.definition);
+    shape[resolvedField.definition.id] = buildFieldSchema(resolvedField.definition, externalEnums, data);
   }
   return zod.z.object(shape);
 }