@waypointjs/core 0.1.0

package/dist/index.js

@@ -0,0 +1,758 @@
+import { createStore } from 'zustand/vanilla';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { z } from 'zod';
+
+// src/conditions.ts
+function resolveFieldValue(path, data, externalVars) {
+  if (path.startsWith("$ext.")) {
+    const varId = path.slice(5);
+    return externalVars[varId];
+  }
+  const dotIndex = path.indexOf(".");
+  if (dotIndex === -1) return void 0;
+  const stepId = path.slice(0, dotIndex);
+  const fieldId = path.slice(dotIndex + 1);
+  return data[stepId]?.[fieldId];
+}
+function evaluateOperator(operator, actual, expected) {
+  switch (operator) {
+    case "exists":
+      return actual !== void 0 && actual !== null && actual !== "";
+    case "notExists":
+      return actual === void 0 || actual === null || actual === "";
+    case "equals":
+      return actual === expected;
+    case "notEquals":
+      return actual !== expected;
+    case "greaterThan":
+      return typeof actual === "number" && typeof expected === "number" ? actual > expected : Number(actual) > Number(expected);
+    case "greaterThanOrEqual":
+      return typeof actual === "number" && typeof expected === "number" ? actual >= expected : Number(actual) >= Number(expected);
+    case "lessThan":
+      return typeof actual === "number" && typeof expected === "number" ? actual < expected : Number(actual) < Number(expected);
+    case "lessThanOrEqual":
+      return typeof actual === "number" && typeof expected === "number" ? actual <= expected : Number(actual) <= Number(expected);
+    case "contains":
+      if (typeof actual === "string" && typeof expected === "string") {
+        return actual.includes(expected);
+      }
+      if (Array.isArray(actual)) {
+        return actual.includes(expected);
+      }
+      return false;
+    case "notContains":
+      if (typeof actual === "string" && typeof expected === "string") {
+        return !actual.includes(expected);
+      }
+      if (Array.isArray(actual)) {
+        return !actual.includes(expected);
+      }
+      return true;
+    case "in":
+      return Array.isArray(expected) && expected.includes(actual);
+    case "notIn":
+      return Array.isArray(expected) && !expected.includes(actual);
+    case "matches":
+      if (typeof actual !== "string" || typeof expected !== "string") return false;
+      try {
+        return new RegExp(expected).test(actual);
+      } catch {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+function evaluateRule(rule, data, externalVars) {
+  const actual = resolveFieldValue(rule.field, data, externalVars);
+  return evaluateOperator(rule.operator, actual, rule.value);
+}
+function evaluateConditionGroup(group, data, externalVars) {
+  const ruleResults = group.rules.map(
+    (rule) => evaluateRule(rule, data, externalVars)
+  );
+  const groupResults = (group.groups ?? []).map(
+    (subGroup) => evaluateConditionGroup(subGroup, data, externalVars)
+  );
+  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) {
+  if (!visibleWhen) return true;
+  return evaluateConditionGroup(visibleWhen, data, externalVars);
+}
+
+// src/tree-resolver.ts
+function areDependenciesMet(dependsOn, data, externalVars) {
+  if (!dependsOn || dependsOn.length === 0) return true;
+  return dependsOn.every((path) => {
+    const value = resolveFieldValue(path, data, externalVars);
+    return value !== void 0 && value !== null && value !== "";
+  });
+}
+function findMissingBlockingVars(externalVariables, externalVars, visibleSteps) {
+  if (!externalVariables || externalVariables.length === 0) return [];
+  const visibleStepIds = new Set(visibleSteps.map((s) => s.id));
+  return externalVariables.filter((extVar) => {
+    if (!extVar.blocking) return false;
+    const usedInVisibleStep = extVar.usedIn?.some(
+      (ref) => visibleStepIds.has(ref.stepId)
+    );
+    if (!usedInVisibleStep) return false;
+    const value = externalVars[extVar.id];
+    return value === void 0 || value === null;
+  }).map((extVar) => extVar.id);
+}
+function resolveTree(schema, data, externalVars) {
+  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 resolvedStep = {
+      definition: stepDef,
+      visible: stepVisible,
+      fields: resolvedFields
+    };
+    if (stepVisible) {
+      visibleSteps.push(resolvedStep);
+    } else {
+      hiddenSteps.push(resolvedStep);
+    }
+  }
+  const missingExternalVars = findMissingBlockingVars(
+    schema.externalVariables,
+    externalVars,
+    visibleSteps.map((s) => s.definition)
+  );
+  return {
+    steps: visibleSteps,
+    hiddenSteps,
+    missingExternalVars
+  };
+}
+function findStepIndex(steps, stepId) {
+  return steps.findIndex((s) => s.definition.id === stepId);
+}
+function getNextStep(steps, currentStepId) {
+  const index = findStepIndex(steps, currentStepId);
+  if (index === -1 || index === steps.length - 1) return void 0;
+  return steps[index + 1];
+}
+function getPreviousStep(steps, currentStepId) {
+  const index = findStepIndex(steps, currentStepId);
+  if (index <= 0) return void 0;
+  return steps[index - 1];
+}
+function calculateProgress(steps, currentStepId) {
+  if (steps.length === 0) return 0;
+  const index = findStepIndex(steps, currentStepId);
+  if (index === -1) return 0;
+  return Math.round((index + 1) / (steps.length + 1) * 100);
+}
+function findLastValidStep(steps, data, _externalVars) {
+  let lastValid;
+  for (const step of steps) {
+    const visibleFields = step.fields.filter((f) => f.visible);
+    const allDepsMet = visibleFields.every((f) => f.dependenciesMet);
+    if (allDepsMet) {
+      const stepData = data[step.definition.id];
+      const hasData = stepData !== void 0 && Object.keys(stepData).length > 0;
+      if (hasData || step === steps[0]) {
+        lastValid = step;
+      } else {
+        break;
+      }
+    } else {
+      break;
+    }
+  }
+  return lastValid ?? steps[0];
+}
+function getResolvedTree(state) {
+  if (!state.schema) {
+    return { steps: [], hiddenSteps: [], missingExternalVars: [] };
+  }
+  return resolveTree(state.schema, state.data, state.externalVars);
+}
+function getCurrentStep(state) {
+  if (!state.currentStepId) return void 0;
+  return getResolvedTree(state).steps.find(
+    (s) => s.definition.id === state.currentStepId
+  );
+}
+function getNextStepFromState(state) {
+  if (!state.currentStepId) return void 0;
+  const tree = getResolvedTree(state);
+  return getNextStep(tree.steps, state.currentStepId);
+}
+function getPreviousStepFromState(state) {
+  if (!state.currentStepId) return void 0;
+  const tree = getResolvedTree(state);
+  return getPreviousStep(tree.steps, state.currentStepId);
+}
+function calculateProgressFromState(state) {
+  if (!state.currentStepId) return 0;
+  const tree = getResolvedTree(state);
+  return calculateProgress(tree.steps, state.currentStepId);
+}
+function getMissingBlockingVars(state) {
+  return getResolvedTree(state).missingExternalVars;
+}
+var initialState = {
+  schema: null,
+  data: {},
+  externalVars: {},
+  currentStepId: null,
+  history: [],
+  isSubmitting: false,
+  completed: false
+};
+function buildStateCreator() {
+  return (set, _get) => ({
+    ...initialState,
+    init(schema, options = {}) {
+      const { data = {}, externalVars = {}, startStepId } = options;
+      const firstStepId = startStepId ?? schema.steps[0]?.id ?? null;
+      set({
+        schema,
+        data,
+        externalVars,
+        currentStepId: firstStepId,
+        history: firstStepId ? [firstStepId] : [],
+        isSubmitting: false,
+        completed: false
+      });
+    },
+    resume(schema, externalVars = {}) {
+      set((state) => ({
+        schema,
+        externalVars: { ...state.externalVars, ...externalVars },
+        isSubmitting: false
+      }));
+    },
+    setFieldValue(stepId, fieldId, value) {
+      set((state) => ({
+        data: {
+          ...state.data,
+          [stepId]: { ...state.data[stepId], [fieldId]: value }
+        }
+      }));
+    },
+    setStepData(stepId, data) {
+      set((state) => ({
+        data: { ...state.data, [stepId]: data }
+      }));
+    },
+    setExternalVar(varId, value) {
+      set((state) => ({
+        externalVars: { ...state.externalVars, [varId]: value }
+      }));
+    },
+    setCurrentStep(stepId) {
+      set((state) => ({
+        currentStepId: stepId,
+        history: state.history.includes(stepId) ? state.history : [...state.history, stepId]
+      }));
+    },
+    setIsSubmitting(b) {
+      set({ isSubmitting: b });
+    },
+    setCompleted(b) {
+      set({ completed: b });
+    },
+    truncateHistoryAt(stepId) {
+      set((state) => {
+        const idx = state.history.indexOf(stepId);
+        if (idx === -1 || idx === state.history.length - 1) return state;
+        return { history: state.history.slice(0, idx + 1) };
+      });
+    },
+    reset() {
+      set(initialState);
+    }
+  });
+}
+function createRuntimeStore(options = {}) {
+  const { persistenceMode, schemaId } = options;
+  if (persistenceMode === "zustand") {
+    const storageKey = schemaId ? `waypoint-runtime-${schemaId}` : "waypoint-runtime";
+    return createStore()(
+      persist(buildStateCreator(), {
+        name: storageKey,
+        storage: createJSONStorage(() => {
+          if (typeof window === "undefined") {
+            return {
+              getItem: () => null,
+              setItem: () => {
+              },
+              removeItem: () => {
+              }
+            };
+          }
+          return window.localStorage;
+        }),
+        partialize: (state) => ({
+          // Persist the schema id so WaypointRunner can verify the saved data
+          // belongs to this schema (guards against stale data from a renamed schema).
+          schemaId: state.schema?.id ?? null,
+          data: state.data,
+          currentStepId: state.currentStepId,
+          history: state.history,
+          completed: state.completed
+        })
+      })
+    );
+  }
+  return createStore()(buildStateCreator());
+}
+function hasPersistedState(store, schemaId) {
+  const state = store.getState();
+  const persistedSchemaId = state["schemaId"];
+  return persistedSchemaId === schemaId && state.currentStepId !== null && !state.completed;
+}
+var customValidatorRegistry = {};
+function registerCustomValidator(id, fn) {
+  customValidatorRegistry[id] = fn;
+}
+function buildFieldSchema(field) {
+  const rules = field.validation ?? [];
+  const isRequired = rules.some((r) => r.type === "required");
+  const isNumeric = field.type === "number";
+  const isCheckbox = field.type === "checkbox";
+  const isMultiSelect = field.type === "multiselect";
+  if (isCheckbox) {
+    const base = z.boolean();
+    return isRequired ? base : base.optional();
+  }
+  if (isMultiSelect) {
+    const base = z.array(z.string());
+    return isRequired ? base.min(1, rules.find((r) => r.type === "required")?.message ?? "Required") : base.optional();
+  }
+  if (isNumeric) {
+    let numSchema = z.coerce.number({
+      invalid_type_error: "Must be a number"
+    });
+    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);
+      }
+    }
+    return isRequired ? numSchema : numSchema.optional();
+  }
+  let strSchema = z.string();
+  const refineRules = [];
+  for (const rule of rules) {
+    switch (rule.type) {
+      case "required":
+        strSchema = strSchema.min(1, rule.message);
+        break;
+      case "minLength": {
+        const n = Number(rule.value);
+        if (!isNaN(n)) strSchema = strSchema.min(n, rule.message);
+        break;
+      }
+      case "maxLength": {
+        const n = Number(rule.value);
+        if (!isNaN(n)) strSchema = strSchema.max(n, rule.message);
+        break;
+      }
+      case "email":
+        strSchema = strSchema.email(rule.message);
+        break;
+      case "url":
+        strSchema = strSchema.url(rule.message);
+        break;
+      case "regex":
+        if (rule.value !== void 0 && rule.value !== null) {
+          strSchema = strSchema.regex(new RegExp(String(rule.value)), rule.message);
+        }
+        break;
+      case "custom":
+        if (rule.customValidatorId && customValidatorRegistry[rule.customValidatorId]) {
+          refineRules.push({ id: rule.customValidatorId, 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
+    );
+  }
+  return finalSchema;
+}
+function buildZodSchema(fields) {
+  const shape = {};
+  for (const resolvedField of fields) {
+    if (!resolvedField.visible) continue;
+    shape[resolvedField.definition.id] = buildFieldSchema(resolvedField.definition);
+  }
+  return z.object(shape);
+}
+
+// src/validate-schema.ts
+var SUPPORTED_VERSIONS = ["1"];
+var VALID_PERSISTENCE_MODES = /* @__PURE__ */ new Set(["zustand", "backend-step", "backend-manual"]);
+var VALID_EXT_VAR_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "object"]);
+var VALID_CONDITION_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "notEquals",
+  "greaterThan",
+  "greaterThanOrEqual",
+  "lessThan",
+  "lessThanOrEqual",
+  "contains",
+  "notContains",
+  "in",
+  "notIn",
+  "exists",
+  "notExists",
+  "matches"
+]);
+var VALID_VALIDATION_TYPES = /* @__PURE__ */ new Set([
+  "required",
+  "min",
+  "max",
+  "minLength",
+  "maxLength",
+  "email",
+  "url",
+  "regex",
+  "custom"
+]);
+function validateSchema(raw) {
+  const errors = [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { valid: false, errors: ["Root must be a JSON object"] };
+  }
+  const obj = raw;
+  if (!("version" in obj)) {
+    errors.push('Missing required field "version"');
+  } else if (!SUPPORTED_VERSIONS.includes(obj.version)) {
+    errors.push(`Unsupported version "${obj.version}". Supported: ${SUPPORTED_VERSIONS.join(", ")}`);
+  }
+  if (!("id" in obj) || typeof obj.id !== "string" || !obj.id.trim()) {
+    errors.push('Field "id" must be a non-empty string');
+  }
+  if (!("name" in obj) || typeof obj.name !== "string" || !obj.name.trim()) {
+    errors.push('Field "name" must be a non-empty string');
+  }
+  if (!("steps" in obj) || !Array.isArray(obj.steps)) {
+    errors.push('Field "steps" must be an array');
+  } else {
+    validateSteps(obj.steps, errors);
+  }
+  if ("persistenceMode" in obj && !VALID_PERSISTENCE_MODES.has(obj.persistenceMode)) {
+    errors.push(
+      `Invalid "persistenceMode" "${obj.persistenceMode}". Must be one of: ${[...VALID_PERSISTENCE_MODES].join(", ")}`
+    );
+  }
+  if ("externalVariables" in obj) {
+    if (!Array.isArray(obj.externalVariables)) {
+      errors.push('"externalVariables" must be an array');
+    } else {
+      validateExternalVariables(obj.externalVariables, errors);
+    }
+  }
+  if ("customTypes" in obj && !Array.isArray(obj.customTypes)) {
+    errors.push('"customTypes" must be an array');
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateSteps(steps, errors) {
+  const seenIds = /* @__PURE__ */ new Set();
+  steps.forEach((step, i) => {
+    const prefix = `steps[${i}]`;
+    if (!step || typeof step !== "object" || Array.isArray(step)) {
+      errors.push(`${prefix}: must be an object`);
+      return;
+    }
+    const s = step;
+    if (typeof s.id !== "string" || !s.id.trim()) {
+      errors.push(`${prefix}: "id" must be a non-empty string`);
+    } else if (seenIds.has(s.id)) {
+      errors.push(`${prefix}: duplicate step id "${s.id}"`);
+    } else {
+      seenIds.add(s.id);
+    }
+    if (typeof s.title !== "string" || !s.title.trim()) {
+      errors.push(`${prefix}: "title" must be a non-empty string`);
+    }
+    if (typeof s.url !== "string" || !s.url.trim()) {
+      errors.push(`${prefix}: "url" must be a non-empty string`);
+    }
+    if (!Array.isArray(s.fields)) {
+      errors.push(`${prefix}: "fields" must be an array`);
+    } else {
+      validateFields(s.fields, s.id, prefix, errors);
+    }
+    if ("visibleWhen" in s) {
+      validateConditionGroup(s.visibleWhen, `${prefix}.visibleWhen`, errors);
+    }
+  });
+}
+function validateFields(fields, stepId, parentPrefix, errors) {
+  const seenIds = /* @__PURE__ */ new Set();
+  fields.forEach((field, i) => {
+    const prefix = `${parentPrefix}.fields[${i}]`;
+    if (!field || typeof field !== "object" || Array.isArray(field)) {
+      errors.push(`${prefix}: must be an object`);
+      return;
+    }
+    const f = field;
+    if (typeof f.id !== "string" || !f.id.trim()) {
+      errors.push(`${prefix}: "id" must be a non-empty string`);
+    } else if (seenIds.has(f.id)) {
+      errors.push(`${prefix}: duplicate field id "${f.id}" in step "${stepId}"`);
+    } else {
+      seenIds.add(f.id);
+    }
+    if (typeof f.type !== "string" || !f.type.trim()) {
+      errors.push(`${prefix}: "type" must be a non-empty string`);
+    }
+    if (typeof f.label !== "string" || !f.label.trim()) {
+      errors.push(`${prefix}: "label" must be a non-empty string`);
+    }
+    if ("options" in f && !Array.isArray(f.options)) {
+      errors.push(`${prefix}: "options" must be an array`);
+    }
+    if ("validation" in f) {
+      if (!Array.isArray(f.validation)) {
+        errors.push(`${prefix}: "validation" must be an array`);
+      } else {
+        validateValidationRules(f.validation, prefix, errors);
+      }
+    }
+    if ("dependsOn" in f) {
+      if (!Array.isArray(f.dependsOn)) {
+        errors.push(`${prefix}: "dependsOn" must be an array`);
+      } else {
+        for (const dep of f.dependsOn) {
+          if (typeof dep !== "string") {
+            errors.push(`${prefix}: each "dependsOn" entry must be a string`);
+          }
+        }
+      }
+    }
+    if ("visibleWhen" in f) {
+      validateConditionGroup(f.visibleWhen, `${prefix}.visibleWhen`, errors);
+    }
+  });
+}
+function validateConditionGroup(group, prefix, errors) {
+  if (!group || typeof group !== "object" || Array.isArray(group)) {
+    errors.push(`${prefix}: must be an object`);
+    return;
+  }
+  const g = group;
+  if (g.combinator !== "and" && g.combinator !== "or") {
+    errors.push(`${prefix}: "combinator" must be "and" or "or"`);
+  }
+  if (!Array.isArray(g.rules)) {
+    errors.push(`${prefix}: "rules" must be an array`);
+  } else {
+    g.rules.forEach((rule, i) => {
+      validateConditionRule(rule, `${prefix}.rules[${i}]`, errors);
+    });
+  }
+  if ("groups" in g && Array.isArray(g.groups)) {
+    g.groups.forEach((nested, i) => {
+      validateConditionGroup(nested, `${prefix}.groups[${i}]`, errors);
+    });
+  }
+}
+function validateConditionRule(rule, prefix, errors) {
+  if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+    errors.push(`${prefix}: must be an object`);
+    return;
+  }
+  const r = rule;
+  if (typeof r.field !== "string" || !r.field.trim()) {
+    errors.push(`${prefix}: "field" must be a non-empty string`);
+  }
+  if (!VALID_CONDITION_OPERATORS.has(r.operator)) {
+    errors.push(
+      `${prefix}: invalid operator "${r.operator}". Must be one of: ${[...VALID_CONDITION_OPERATORS].join(", ")}`
+    );
+  }
+}
+function validateValidationRules(rules, parentPrefix, errors) {
+  rules.forEach((rule, i) => {
+    const prefix = `${parentPrefix}.validation[${i}]`;
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+      errors.push(`${prefix}: must be an object`);
+      return;
+    }
+    const r = rule;
+    if (!VALID_VALIDATION_TYPES.has(r.type)) {
+      errors.push(
+        `${prefix}: invalid type "${r.type}". Must be one of: ${[...VALID_VALIDATION_TYPES].join(", ")}`
+      );
+    }
+    if (typeof r.message !== "string" || !r.message.trim()) {
+      errors.push(`${prefix}: "message" must be a non-empty string`);
+    }
+  });
+}
+function validateExternalVariables(vars, errors) {
+  const seenIds = /* @__PURE__ */ new Set();
+  vars.forEach((v, i) => {
+    const prefix = `externalVariables[${i}]`;
+    if (!v || typeof v !== "object" || Array.isArray(v)) {
+      errors.push(`${prefix}: must be an object`);
+      return;
+    }
+    const ev = v;
+    if (typeof ev.id !== "string" || !ev.id.trim()) {
+      errors.push(`${prefix}: "id" must be a non-empty string`);
+    } else if (seenIds.has(ev.id)) {
+      errors.push(`${prefix}: duplicate external variable id "${ev.id}"`);
+    } else {
+      seenIds.add(ev.id);
+    }
+    if (typeof ev.label !== "string" || !ev.label.trim()) {
+      errors.push(`${prefix}: "label" must be a non-empty string`);
+    }
+    if (!VALID_EXT_VAR_TYPES.has(ev.type)) {
+      errors.push(
+        `${prefix}: invalid type "${ev.type}". Must be one of: ${[...VALID_EXT_VAR_TYPES].join(", ")}`
+      );
+    }
+    if (typeof ev.blocking !== "boolean") {
+      errors.push(`${prefix}: "blocking" must be a boolean`);
+    }
+  });
+}
+function assertSchema(raw) {
+  const result = validateSchema(raw);
+  if (!result.valid) {
+    throw new Error(`Invalid WaypointSchema:
+${result.errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+}
+
+// src/url.ts
+var URLTemplateEngine = class {
+  /**
+   * Replace all `{{PARAM}}` placeholders in a template with the provided values.
+   * Missing params are left as-is.
+   */
+  static format(template, params) {
+    return template.replace(this.PLACEHOLDER_PATTERN, (match, key) => {
+      const value = params[key];
+      if (value === void 0 || value === null) {
+        console.log(`Waypoint: missing parameter "${key}" in URL: ${template}`);
+        return match;
+      }
+      return String(value);
+    });
+  }
+  /**
+   * Extract all placeholder names from a URL template.
+   */
+  static extractPlaceholders(template) {
+    const matches = template.match(this.PLACEHOLDER_PATTERN);
+    return matches ? matches.map((m) => m.replace(/[{}]/g, "")) : [];
+  }
+  /**
+   * Validate that all placeholders in the template have corresponding params.
+   */
+  static validate(template, params) {
+    const placeholders = this.extractPlaceholders(template);
+    const missingParams = placeholders.filter((key) => params[key] === void 0);
+    return { isValid: missingParams.length === 0, missingParams };
+  }
+};
+URLTemplateEngine.PLACEHOLDER_PATTERN = /\{\{([^}]+)\}\}/g;
+function doesPatternMatchURL(pathname, urlPattern) {
+  const regexPattern = urlPattern.replace(/\{\{([^}]+)\}\}/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${regexPattern}$`).test(pathname);
+}
+function doesPatternPartiallyMatch(pathname, urlPattern) {
+  const patternBase = urlPattern.replace(/\{\{[^}]+\}\}/g, "*").split("/").filter((segment) => segment !== "*" && segment !== "");
+  const pathSegments = pathname.split("/").filter((s) => s !== "");
+  let patternIndex = 0;
+  for (const seg of pathSegments) {
+    if (patternIndex < patternBase.length && seg === patternBase[patternIndex]) {
+      patternIndex++;
+    }
+  }
+  return patternIndex === patternBase.length;
+}
+function extractParamsFromPattern(pathname, urlPattern) {
+  const params = {};
+  const placeholders = [];
+  const regexPattern = urlPattern.replace(
+    /\{\{([^}]+)\}\}/g,
+    (_match, paramName) => {
+      placeholders.push(paramName);
+      return "([^/]+)";
+    }
+  );
+  const regex = new RegExp(`^${regexPattern.replace(/\//g, "\\/")}$`);
+  const matches = pathname.match(regex);
+  if (matches) {
+    for (let i = 1; i < matches.length; i++) {
+      const paramName = placeholders[i - 1];
+      const paramValue = matches[i];
+      if (paramName.includes("_ID") && /^\d+$/.test(paramValue)) {
+        params[paramName] = parseInt(paramValue, 10);
+      } else {
+        params[paramName] = paramValue;
+      }
+    }
+  }
+  return params;
+}
+function findMatchingStep(pathname, allSteps) {
+  for (const step of allSteps) {
+    if (doesPatternMatchURL(pathname, step.url)) return step;
+  }
+  for (const step of allSteps) {
+    if (doesPatternPartiallyMatch(pathname, step.url)) return step;
+  }
+  return null;
+}
+function extractURLParamsFromTree(pathname, allSteps) {
+  const matching = findMatchingStep(pathname, allSteps);
+  if (!matching) return {};
+  return extractParamsFromPattern(pathname, matching.url);
+}
+function extractOnlyMissingParams(pathname, allSteps, missingParamNames) {
+  if (missingParamNames.length === 0) return {};
+  const matching = findMatchingStep(pathname, allSteps);
+  if (!matching) return {};
+  const all = extractParamsFromPattern(pathname, matching.url);
+  const filtered = {};
+  for (const name of missingParamNames) {
+    if (all[name] !== void 0) filtered[name] = all[name];
+  }
+  return filtered;
+}
+function mergeContextParams(userParams = {}, pathname, allSteps, targetURL) {
+  let urlParams = {};
+  if (targetURL) {
+    const required = URLTemplateEngine.extractPlaceholders(targetURL);
+    const missing = required.filter((p) => userParams[p] === void 0);
+    urlParams = extractOnlyMissingParams(pathname, allSteps, missing);
+  } else {
+    urlParams = extractURLParamsFromTree(pathname, allSteps);
+  }
+  return { ...urlParams, ...userParams };
+}
+
+export { URLTemplateEngine, assertSchema, buildZodSchema, calculateProgress, calculateProgressFromState, createRuntimeStore, evaluateConditionGroup, extractOnlyMissingParams, extractURLParamsFromTree, findLastValidStep, findMatchingStep, findStepIndex, getCurrentStep, getMissingBlockingVars, getNextStep, getNextStepFromState, getPreviousStep, getPreviousStepFromState, getResolvedTree, hasPersistedState, isVisible, mergeContextParams, registerCustomValidator, resolveFieldValue, resolveTree, validateSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map