@jfdevelops/multi-step-form-core 1.0.0-alpha.11

package/dist/types-C4Mgnku6.cjs

@@ -0,0 +1,949 @@
+"use strict";
+function comparePartialArray(compareArray, actualArray, formatter) {
+  const errors = [];
+  const compareSet = new Set(compareArray);
+  const printedArray = formatter ? formatter.format(compareArray.map((value) => `${value}`)) : `[${compareArray.join(", ")}]`;
+  for (let i = 0; i < actualArray.length; i++) {
+    const value = actualArray[i];
+    if (!compareSet.has(value)) {
+      errors.push(
+        `Extra element at index ${i}: "${value}" is not in ${printedArray}`
+      );
+    }
+  }
+  const hasAtLeastOne = actualArray.some((v) => compareSet.has(v));
+  if (!hasAtLeastOne) {
+    errors.push(
+      `Array must contain at least one valid element from ${printedArray}`
+    );
+  }
+  if (errors.length > 0) {
+    return { status: "error", errors };
+  }
+  return { status: "success" };
+}
+function printErrors(errors, mapper) {
+  const defaultMapper = (e, i) => `❌ ${i + 1}. ${e}`;
+  return errors.map((e, i) => defaultMapper(e, i)).join("\n");
+}
+function typedObjectKeys(value) {
+  return Object.keys(value);
+}
+function lazy(strings, ...values) {
+  return () => String.raw({ raw: strings }, ...values);
+}
+function invariant(condition, message, error = Error) {
+  if (!condition) {
+    const formatter = new Intl.ListFormat("en", {
+      style: "long",
+      type: "conjunction"
+    });
+    const resolvedMessage = typeof message === "function" ? message(formatter) : lazy`${message}`();
+    throw new error(resolvedMessage);
+  }
+}
+function extractNumber(input) {
+  invariant(input.includes("step"), "Can't extract a valid step number since");
+  const extracted = input.replace("step", "");
+  invariant(/^\d+$/.test(extracted), `Invalid step format: "${input}"`);
+  return Number.parseInt(extracted, 10);
+}
+function getStep(resolvedStepValues) {
+  return function(options) {
+    const { step } = options;
+    const stepKey = `step${step}`;
+    const data = resolvedStepValues[stepKey];
+    return { step, data };
+  };
+}
+function createCtxHelper(values, data) {
+  return data.reduce((acc, curr) => {
+    const stepNumber = extractNumber(curr);
+    const { data: data2 } = getStep(values)({
+      step: stepNumber
+    });
+    for (const [key, value] of Object.entries(data2)) {
+      if (typeof value === "function" && key !== "update") {
+        continue;
+      }
+      data2[key] = value;
+    }
+    acc[curr] = data2;
+    return acc;
+  }, {});
+}
+function createCtx(values, stepData) {
+  const formatter = new Intl.ListFormat("en", {
+    style: "long",
+    type: "disjunction"
+  });
+  const validStepKeys = Object.keys(values);
+  const baseErrorMessage = () => {
+    return `"stepData" must be set to an array of available steps (${formatter.format(
+      validStepKeys
+    )})`;
+  };
+  if (stepData === "all") {
+    let ctx = {};
+    for (const key of validStepKeys) {
+      ctx = {
+        ...ctx,
+        [key]: getStep(values)({
+          step: extractNumber(key)
+        })
+      };
+    }
+    return createCtxHelper(
+      values,
+      validStepKeys
+    );
+  }
+  if (Array.isArray(stepData)) {
+    invariant(
+      stepData.every((step) => validStepKeys.includes(step)),
+      () => {
+        const comparedResults = comparePartialArray(
+          stepData,
+          validStepKeys.map((key) => extractNumber(key)),
+          formatter
+        );
+        if (comparedResults.status === "error") {
+          return `${baseErrorMessage()}. See errors:
+ ${printErrors(
+            comparedResults.errors
+          )}`;
+        }
+        return baseErrorMessage();
+      }
+    );
+    return createCtxHelper(
+      values,
+      stepData
+    );
+  }
+  if (typeof stepData === "object") {
+    const keys = Object.keys(stepData);
+    invariant(
+      keys.every((key) => validStepKeys.includes(key)),
+      () => {
+        const comparedResults = comparePartialArray(
+          keys,
+          validStepKeys,
+          formatter
+        );
+        if (comparedResults.status === "error") {
+          return `${baseErrorMessage()}. See errors:
+ ${printErrors(
+            comparedResults.errors
+          )}`;
+        }
+        return baseErrorMessage();
+      }
+    );
+    return createCtxHelper(
+      values,
+      keys
+    );
+  }
+  throw new Error(`${baseErrorMessage()} OR to "all"`);
+}
+function functionalUpdate(updater, input) {
+  if (typeof updater === "function") {
+    return updater(input);
+  }
+  return updater;
+}
+const DEFAULT_LOGGER_PREFIX = "MultiStepFormSchema";
+class MultiStepFormLogger {
+  debug;
+  prefix = DEFAULT_LOGGER_PREFIX;
+  includeTimestamp = false;
+  throwOnError = false;
+  constructor(options) {
+    this.debug = options?.debug ?? false;
+    if (this.debug && options?.debug) {
+      const {
+        includeTimestamp = false,
+        prefix = DEFAULT_LOGGER_PREFIX,
+        throwOnError = false
+      } = options;
+      this.includeTimestamp = includeTimestamp;
+      this.prefix = typeof prefix === "string" ? prefix : prefix(DEFAULT_LOGGER_PREFIX);
+      this.throwOnError = throwOnError;
+    }
+  }
+  wrapValue(wrapWith, value) {
+    if (wrapWith === "[]") {
+      return `[${value}]`;
+    }
+    if (wrapWith === "{}") {
+      return `{${value}}`;
+    }
+    if (wrapWith === "none") {
+      return value;
+    }
+    throw new Error(
+      `The first argument ${wrapWith} is not valid. Valid options include: "[]", "{}", and "none"`
+    );
+  }
+  formatPrefix(options) {
+    if (!options) {
+      return this.prefix;
+    }
+    const { action, value, wrapWith } = options;
+    if (action === "replace") {
+      return this.wrapValue(wrapWith ?? "[]", value);
+    }
+    const { delimiter } = options;
+    if (action === "append") {
+      return `${this.wrapValue(
+        wrapWith?.originalPrefix ?? "[]",
+        this.prefix
+      )}${delimiter}${this.wrapValue(
+        wrapWith?.addedPrefix ?? "[]",
+        value
+      )}`.trim();
+    }
+    if (action === "prepend") {
+      return `${this.wrapValue(
+        wrapWith?.addedPrefix ?? "[]",
+        value
+      )}${delimiter}${this.wrapValue(
+        wrapWith?.originalPrefix ?? "[]",
+        this.prefix
+      )}`.trim();
+    }
+    return this.prefix;
+  }
+  formatMessage(level, message, options) {
+    const {
+      includeTimestamp = this.includeTimestamp,
+      prefix,
+      logLevelOptions
+    } = options ?? {};
+    const formattedPrefix = this.formatPrefix(prefix);
+    const formattedLogLevel = this.wrapValue(
+      logLevelOptions?.wrapWith ?? "[]",
+      (logLevelOptions?.level ?? level).toUpperCase()
+    );
+    const formattedMessage = `${formattedPrefix} ${formattedLogLevel} ${message}`;
+    if (includeTimestamp) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      return `[${timestamp}] ${formattedMessage}`;
+    }
+    return formattedMessage;
+  }
+  info(message, options) {
+    if (!this.debug) {
+      return;
+    }
+    console.info(this.formatMessage("info", message, options));
+  }
+  warn(message, options) {
+    if (!this.debug) {
+      return;
+    }
+    console.warn(this.formatMessage("warn", message, options));
+  }
+  error(message, options) {
+    if (!this.debug) {
+      return;
+    }
+    const formatted = this.formatMessage("error", message, options);
+    console.error(formatted);
+    const throwOnError = options?.throw ?? this.throwOnError;
+    if (throwOnError) {
+      throw new Error(formatted);
+    }
+  }
+}
+exports.path = void 0;
+((path2) => {
+  function getBy(obj, path3) {
+    return path3.split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+  }
+  function setBy(target, path3, value) {
+    const keys = path3.split(".");
+    let current = target;
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      if (i === keys.length - 1) {
+        if (current[k] !== void 0 && typeof current[k] === "object" && typeof value === "object" && value !== null) {
+          Object.assign(current[k], value);
+        } else {
+          current[k] = value;
+        }
+      } else {
+        if (typeof current[k] !== "object" || current[k] === null) {
+          current[k] = {};
+        }
+        current = current[k];
+      }
+    }
+    return current;
+  }
+  path2.setBy = setBy;
+  function normalizePaths(...paths) {
+    const sorted = [...paths].sort(
+      (a, b) => b.split(".").length - a.split(".").length
+    );
+    const finalPaths = [];
+    for (const path3 of sorted) {
+      const isCovered = finalPaths.some((p) => p.startsWith(path3 + "."));
+      if (!isCovered) {
+        finalPaths.push(path3);
+      }
+    }
+    return finalPaths.reverse();
+  }
+  path2.normalizePaths = normalizePaths;
+  function pickBy(obj, ...paths) {
+    const norm = normalizePaths(...paths);
+    if (norm.length === 1) {
+      return getBy(obj, norm[0]);
+    }
+    const result = {};
+    for (const p of norm) {
+      const value = getBy(obj, p);
+      setBy(result, p, value);
+    }
+    return result;
+  }
+  path2.pickBy = pickBy;
+  function createDeep(obj) {
+    const paths = [];
+    function traverse(current, prefix = "") {
+      if (current === null || current === void 0) {
+        return;
+      }
+      if (typeof current !== "object" || Array.isArray(current)) {
+        return;
+      }
+      const keys = Object.keys(current);
+      for (const key of keys) {
+        const path3 = prefix ? `${prefix}.${key}` : key;
+        paths.push(path3);
+        const value = current[key];
+        if (value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value)) {
+          traverse(value, path3);
+        }
+      }
+    }
+    traverse(obj);
+    return paths;
+  }
+  path2.createDeep = createDeep;
+  function defaultExpectedFormat(value) {
+    if (value === null) return "null";
+    if (Array.isArray(value)) return "Array";
+    const t = typeof value;
+    if (t !== "object") return t;
+    const ctor = value?.constructor?.name;
+    return ctor && ctor !== "Object" ? ctor : "object";
+  }
+  function splitPath(path3) {
+    if (!path3) return [];
+    const parts = [];
+    const regex = /[^.[\]]+|\[(\d+)\]/g;
+    let m;
+    while (m = regex.exec(path3)) {
+      parts.push(m[1] ?? m[0]);
+    }
+    return parts;
+  }
+  function getTransformFunction(root, path3) {
+    if (!root) return void 0;
+    if (typeof root === "function") {
+      return root;
+    }
+    const segments = splitPath(path3);
+    let node = root;
+    let lastFn;
+    for (const seg of segments) {
+      if (!node) break;
+      if (typeof node === "function") {
+        lastFn = node;
+        break;
+      }
+      node = node[seg];
+      if (typeof node === "function") {
+        lastFn = node;
+        break;
+      }
+    }
+    return lastFn;
+  }
+  function formatExpected(rawExpected, path3, cfg) {
+    const fn = getTransformFunction(cfg, path3);
+    if (fn) return fn(rawExpected, path3);
+    return defaultExpectedFormat(rawExpected);
+  }
+  function isObjectLike(v) {
+    return typeof v === "object" && v !== null;
+  }
+  function deepCompare(expected, actual, basePath, mismatches, options) {
+    if (expected === actual) {
+      return mismatches;
+    }
+    if (expected === null || actual === null || typeof expected !== "object" || typeof actual !== "object") {
+      const path4 = basePath || "(root)";
+      if (typeof expected !== typeof actual) {
+        mismatches.push({
+          path: path4,
+          expected: formatExpected(expected, path4, options.transformExpected),
+          actual,
+          reason: "type-mismatch"
+        });
+        return mismatches;
+      }
+      if (options.includeValueMismatch) {
+        mismatches.push({
+          path: path4,
+          expected: formatExpected(expected, path4, options.transformExpected),
+          actual,
+          reason: "value-mismatch"
+        });
+      }
+      return mismatches;
+    }
+    if (Array.isArray(expected) || Array.isArray(actual)) {
+      if (!Array.isArray(expected) || !Array.isArray(actual)) {
+        const path4 = basePath || "(root)";
+        mismatches.push({
+          path: path4,
+          expected: formatExpected(expected, path4, options.transformExpected),
+          actual,
+          reason: "type-mismatch"
+        });
+        return mismatches;
+      }
+      const maxLen = expected.length;
+      for (let i = 0; i < maxLen; i++) {
+        const expVal = expected[i];
+        const actVal = actual[i];
+        const path4 = basePath === "" ? `[${i}]` : `${basePath}[${i}]`;
+        deepCompare(expVal, actVal, path4, mismatches, options);
+      }
+      return mismatches;
+    }
+    if (isObjectLike(expected) && isObjectLike(actual)) {
+      const expKeys = Object.keys(expected);
+      const actKeys = Object.keys(actual);
+      for (const key of expKeys) {
+        const expVal = expected[key];
+        const actVal = actual[key];
+        const path4 = basePath ? `${basePath}.${key}` : key;
+        if (!(key in actual)) {
+          mismatches.push({
+            path: path4,
+            expected: formatExpected(expVal, path4, options.transformExpected),
+            actual: void 0,
+            reason: "missing-key"
+          });
+          continue;
+        }
+        deepCompare(expVal, actVal, path4, mismatches, options);
+      }
+      for (const key of actKeys) {
+        if (!(key in expected)) {
+          const path4 = basePath ? `${basePath}.${key}` : key;
+          mismatches.push({
+            path: path4,
+            expected: void 0,
+            actual: actual[key],
+            reason: "extra-key"
+          });
+        }
+      }
+      return mismatches;
+    }
+    const path3 = basePath || "(root)";
+    if (typeof expected !== typeof actual) {
+      mismatches.push({
+        path: path3,
+        expected: formatExpected(expected, path3, options.transformExpected),
+        actual,
+        reason: "type-mismatch"
+      });
+    } else if (options.includeValueMismatch) {
+      mismatches.push({
+        path: path3,
+        expected: formatExpected(expected, path3, options.transformExpected),
+        actual,
+        reason: "value-mismatch"
+      });
+    }
+    return mismatches;
+  }
+  function equalsAtPaths(obj, paths, actual, options) {
+    const expected = pickBy(obj, ...paths);
+    const mismatches = [];
+    const basePath = paths.length === 1 ? paths[0] : "";
+    deepCompare(expected, actual, basePath, mismatches, {
+      transformExpected: options?.transformExpected
+    });
+    return {
+      ok: mismatches.length === 0,
+      mismatches
+    };
+  }
+  path2.equalsAtPaths = equalsAtPaths;
+  function formatValue(v) {
+    if (v === void 0) return "undefined";
+    if (typeof v === "string") return JSON.stringify(v);
+    try {
+      return JSON.stringify(v, null, 2);
+    } catch {
+      return String(v);
+    }
+  }
+  function formatReason(m) {
+    switch (m.reason) {
+      case "missing-key":
+        return "Missing key";
+      case "extra-key":
+        return "Extra key";
+      case "type-mismatch":
+        return "Type mismatch";
+      case "value-mismatch":
+        return "Value mismatch";
+      default:
+        return m.reason;
+    }
+  }
+  function formatMismatches(result) {
+    if (result.ok || result.mismatches.length === 0) {
+      return "No mismatches.";
+    }
+    const lines = [];
+    for (const m of result.mismatches) {
+      lines.push(
+        `
+● ${formatReason(m)} at "${m.path}":`,
+        `    expected: ${formatValue(m.expected)}`,
+        `    actual:   ${formatValue(m.actual)}`,
+        ""
+        // blank line between entries
+      );
+    }
+    if (lines.at(-1) === "") {
+      lines.pop();
+    }
+    return lines.join("\n");
+  }
+  path2.formatMismatches = formatMismatches;
+  function printMismatches(result) {
+    const msg = formatMismatches(result);
+    if (msg !== "No mismatches.") {
+      console.error(msg);
+    }
+  }
+  path2.printMismatches = printMismatches;
+  function setAtImmutable(root, path3, value) {
+    const keys = path3.split(".");
+    function helper(current, idx) {
+      const key = keys[idx];
+      const resolvedCurrent = Array.isArray(current) ? [...current] : { ...current };
+      if (idx === keys.length - 1) {
+        let clone2 = current && typeof current === "object" ? resolvedCurrent : {};
+        clone2 = {
+          ...clone2,
+          [key]: value
+        };
+        return clone2;
+      }
+      const next = current && typeof current === "object" ? current[key] : void 0;
+      const updatedChild = helper(next ?? {}, idx + 1);
+      let clone = current && typeof current === "object" ? resolvedCurrent : {};
+      clone = {
+        ...clone,
+        [key]: updatedChild
+      };
+      return clone;
+    }
+    return helper(root, 0);
+  }
+  function updateAt(obj, paths, value) {
+    const norm = normalizePaths(...paths);
+    if (norm.length === 0) return obj;
+    let result = obj;
+    if (norm.length === 1) {
+      const path3 = norm[0];
+      result = setAtImmutable(result, path3, value);
+      return result;
+    }
+    for (const path3 of norm) {
+      const sub = getBy(value, path3);
+      result = setAtImmutable(result, path3, sub);
+    }
+    return result;
+  }
+  path2.updateAt = updateAt;
+})(exports.path || (exports.path = {}));
+function runStandardValidation(schema, input) {
+  const result = schema["~standard"].validate(input);
+  if (result instanceof Promise) {
+    throw new TypeError("Schema validation must be synchronous", {
+      cause: schema
+    });
+  }
+  if (result.issues) {
+    throw new Error(JSON.stringify(result.issues, null, 2));
+  }
+  return result.value;
+}
+function isValidStepKey(steps, stepKey) {
+  return Object.keys(steps).includes(stepKey);
+}
+class MultiStepFormStepSchemaInternal {
+  #getValue;
+  #setValue;
+  get value() {
+    return this.#getValue();
+  }
+  constructor(options) {
+    const { getValue, setValue } = options;
+    this.#getValue = getValue;
+    this.#setValue = setValue;
+  }
+  handlePostUpdate(value) {
+    this.#setValue(this.enrichValues(value));
+  }
+  createStepUpdaterFnImpl(options) {
+    const { targetStep, updater, ctxData, fields = "all", debug } = options;
+    const logger = new MultiStepFormLogger({
+      debug,
+      prefix: (value) => `${value}:update${targetStep}`
+    });
+    logger.info(`${targetStep} will be updated`);
+    invariant(
+      isValidStepKey(this.value, targetStep),
+      `[update]: The target step ${targetStep} isn't a valid step. Please select a valid step`
+    );
+    const { [targetStep]: currentStep, ...values } = this.value;
+    let updatedValue = { ...this.value };
+    let ctx = createCtx(updatedValue, [targetStep]);
+    if (ctxData) {
+      invariant(
+        typeof ctxData === "function",
+        '[update]: "ctxData" must be a function'
+      );
+      logger.info('Custom "ctx" will be used');
+      const additionalCtx = ctxData({ ctx: values });
+      invariant(
+        typeof additionalCtx === "object" && Object.keys(additionalCtx).length > 0,
+        '[update]: "ctxData" must return an object with keys'
+      );
+      logger.info(
+        `Custom "ctx" consists of the following keys: ${new Intl.ListFormat(
+          "en",
+          {
+            style: "long",
+            type: "conjunction"
+          }
+        ).format(Object.keys(additionalCtx))}`
+      );
+      ctx = {
+        ...ctx,
+        ...additionalCtx
+      };
+    }
+    const updated = functionalUpdate(updater, {
+      ctx,
+      update: this.createHelperFnInputUpdate([targetStep])
+    });
+    logger.info(`The updated data is ${JSON.stringify(updated, null, 2)}`);
+    if (!fields) {
+      invariant(
+        typeof updated === "object",
+        '[update]: "updater" must be an object or a function that returns an object'
+      );
+      const stepKeys = Object.keys(this.value);
+      const updaterResultKeys = Object.keys(updated);
+      invariant(updaterResultKeys.length === stepKeys.length, () => {
+        const missingKeys = stepKeys.filter(
+          (key) => !updaterResultKeys.includes(key)
+        );
+        const formatter = new Intl.ListFormat("en", {
+          style: "long",
+          type: "conjunction"
+        });
+        return `[update]: "updater" is missing keys ${formatter.format(
+          missingKeys
+        )}`;
+      });
+      const paths = exports.path.createDeep(this.value);
+      const { mismatches, ok } = exports.path.equalsAtPaths(
+        this.value,
+        paths,
+        updated
+      );
+      invariant(
+        ok && mismatches.length === 0,
+        `[update]: found value mismatches in ${exports.path.printMismatches({
+          mismatches,
+          ok
+        })}`
+      );
+      logger.info("The entire step will be updated");
+      updatedValue = {
+        ...updatedValue,
+        [targetStep]: exports.path.updateAt(updatedValue, paths, updated)
+      };
+      this.handlePostUpdate(updatedValue);
+      logger.info(`The new value is: ${JSON.stringify(updatedValue, null, 2)}`);
+      return;
+    }
+    const currentStepDeepKeys = exports.path.createDeep(currentStep);
+    if (Array.isArray(fields)) {
+      const compareResult = comparePartialArray(currentStepDeepKeys, fields);
+      invariant(
+        compareResult.status === "success",
+        `[update]: Found errors with the provided fields
+${compareResult.status === "error" ? printErrors(compareResult.errors) : ""}`
+      );
+      const { mismatches, ok } = exports.path.equalsAtPaths(
+        currentStep,
+        fields,
+        updated
+      );
+      invariant(
+        ok && mismatches.length === 0,
+        `[update]: found value mismatches in ${exports.path.printMismatches({
+          ok,
+          mismatches
+        })}`
+      );
+      logger.info(
+        `The following fields will be updated: ${new Intl.ListFormat("en", {
+          type: "conjunction",
+          style: "long"
+        }).format(fields)}`
+      );
+      updatedValue = {
+        ...updatedValue,
+        [targetStep]: exports.path.updateAt(currentStep, fields, updated)
+      };
+      this.handlePostUpdate(updatedValue);
+      logger.info(`The new value is: ${JSON.stringify(updatedValue, null, 2)}`);
+      return;
+    }
+    if (typeof fields === "object" && Object.keys(fields).length > 0) {
+      const keys = exports.path.createDeep(fields);
+      const compareResult = comparePartialArray(
+        currentStepDeepKeys,
+        keys
+      );
+      invariant(
+        compareResult.status === "success",
+        `[update]: Found errors with the provided fields
+${compareResult.status === "error" ? printErrors(compareResult.errors) : ""}`
+      );
+      const { mismatches, ok } = exports.path.equalsAtPaths(
+        currentStep,
+        keys,
+        updated
+      );
+      invariant(
+        ok && mismatches.length === 0,
+        `[update]: found value mismatches in ${exports.path.printMismatches({
+          ok,
+          mismatches
+        })}`
+      );
+      updatedValue = {
+        ...updatedValue,
+        [targetStep]: exports.path.updateAt(
+          currentStep,
+          keys,
+          updated
+        )
+      };
+      logger.info(
+        `The following fields will be updated: ${new Intl.ListFormat("en", {
+          type: "conjunction",
+          style: "long"
+        }).format(Object.keys(fields))}`
+      );
+      this.handlePostUpdate(updatedValue);
+      logger.info(`The new value is: ${JSON.stringify(updatedValue, null, 2)}`);
+      return;
+    }
+    logger.error('Unsupported value for the "fields" option');
+    throw new TypeError(
+      `[update]: property "fields" must be set to one of the following: "all", an array of deep paths to update, or an object of paths. Was ${typeof updater}`,
+      { cause: updater }
+    );
+  }
+  createStepUpdaterFn(targetStep) {
+    return (options) => {
+      this.createStepUpdaterFnImpl({ targetStep, ...options });
+    };
+  }
+  update(options) {
+    return this.createStepUpdaterFnImpl(options);
+  }
+  createHelperFnInputUpdate(chosenSteps) {
+    if (exports.HelperFnChosenSteps.isAll(chosenSteps)) {
+      const stepSpecificUpdateFn = typedObjectKeys(this.value).reduce((acc, key) => {
+        acc[key] = this.createStepUpdaterFn(key);
+        return acc;
+      }, {});
+      const update = Object.assign(
+        this.update,
+        stepSpecificUpdateFn
+      );
+      return update;
+    }
+    const validKeys = Object.keys(this.value);
+    if (exports.HelperFnChosenSteps.isTuple(chosenSteps, validKeys)) {
+      const stepSpecificUpdateFn = chosenSteps.reduce((acc, step) => {
+        acc[step] = this.createStepUpdaterFn(step);
+        return acc;
+      }, {});
+      const update = Object.assign(
+        this.update,
+        stepSpecificUpdateFn
+      );
+      return update;
+    }
+    if (exports.HelperFnChosenSteps.isObject(chosenSteps, validKeys)) {
+      const stepSpecificUpdateFn = typedObjectKeys(chosenSteps).reduce((acc, key) => {
+        acc[key] = this.createStepUpdaterFn(key);
+        return acc;
+      }, {});
+      const update = Object.assign(
+        this.update,
+        stepSpecificUpdateFn
+      );
+      return update;
+    }
+    throw new TypeError(`[update]: ${exports.HelperFnChosenSteps.CATCH_ALL_MESSAGE}`);
+  }
+  createStepHelperFn(stepData) {
+    return (optionsOrFunction, fn) => {
+      const createInputUpdateFn = this.createHelperFnInputUpdate(
+        stepData
+      );
+      if (typeof optionsOrFunction === "function") {
+        return () => {
+          const ctx = createCtx(
+            this.value,
+            stepData
+          );
+          return optionsOrFunction({
+            ctx,
+            update: createInputUpdateFn
+          });
+        };
+      }
+      if (typeof optionsOrFunction === "object") {
+        return (input) => {
+          const ctx = createCtx(
+            this.value,
+            stepData
+          );
+          if ("validator" in optionsOrFunction) {
+            invariant(
+              typeof input === "object",
+              "An input is expected since you provided a validator"
+            );
+            runStandardValidation(
+              optionsOrFunction.validator,
+              input.data
+            );
+            let resolvedCtx = ctx;
+            if (optionsOrFunction.ctxData) {
+              const currentStepKey = stepData[0];
+              const { [currentStepKey]: _, ...values } = this.value;
+              resolvedCtx = {
+                ...resolvedCtx,
+                ...optionsOrFunction.ctxData({ ctx: values })
+              };
+            }
+            return fn({
+              ctx: resolvedCtx,
+              update: createInputUpdateFn,
+              ...input
+            });
+          }
+          return fn({
+            ctx,
+            update: createInputUpdateFn
+          });
+        };
+      }
+      throw new Error(
+        `The first argument must be a function or an object, (was ${typeof optionsOrFunction})`
+      );
+    };
+  }
+  enrichValues(values, additionalProps) {
+    let enriched = { ...values };
+    for (const [key, stepValue] of Object.entries(enriched)) {
+      const [targetStep] = [key];
+      const step = Number.parseInt(
+        targetStep.replace("step", "")
+      );
+      enriched[targetStep] = {
+        ...stepValue,
+        update: this.createStepUpdaterFn(targetStep),
+        createHelperFn: this.createStepHelperFn([targetStep]),
+        ...additionalProps?.(step)
+      };
+    }
+    return enriched;
+  }
+}
+exports.fields = void 0;
+((fields2) => {
+  function resolvedDeepPath(fieldPath, fields3, filler = "defaultValue") {
+    const [parent, ...children] = fieldPath.split(".");
+    const shared = `${parent}.${filler}`;
+    const fullPath = children.length === 0 ? shared : `${shared}.${children.join(".")}`;
+    const resolvedValue = exports.path.pickBy(fields3, fullPath);
+    return resolvedValue;
+  }
+  fields2.resolvedDeepPath = resolvedDeepPath;
+})(exports.fields || (exports.fields = {}));
+exports.HelperFnChosenSteps = void 0;
+((HelperFnChosenSteps2) => {
+  HelperFnChosenSteps2.CATCH_ALL_MESSAGE = 'The chosen steps must either be set to on of the following: "all", an array of steps (["step1", "step2", ...]), or an object containing the steps to chose ({ step1: true, step2: true, ...})';
+  function isAll(value) {
+    return Boolean(value && typeof value === "string" && value === "all");
+  }
+  HelperFnChosenSteps2.isAll = isAll;
+  function isTuple(value, validValues) {
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    if (validValues) {
+      return value.every((key) => validValues.includes(key));
+    }
+    return true;
+  }
+  HelperFnChosenSteps2.isTuple = isTuple;
+  function isObject(value, validKeys) {
+    if (!value) {
+      return false;
+    }
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return false;
+    }
+    if (validKeys && !keys.every((key) => validKeys.includes(key))) {
+      return false;
+    }
+    return Object.entries(value).every(([_, v]) => v === true);
+  }
+  HelperFnChosenSteps2.isObject = isObject;
+})(exports.HelperFnChosenSteps || (exports.HelperFnChosenSteps = {}));
+exports.DEFAULT_LOGGER_PREFIX = DEFAULT_LOGGER_PREFIX;
+exports.MultiStepFormLogger = MultiStepFormLogger;
+exports.MultiStepFormStepSchemaInternal = MultiStepFormStepSchemaInternal;
+exports.createCtx = createCtx;
+exports.getStep = getStep;
+exports.invariant = invariant;
+exports.isValidStepKey = isValidStepKey;
+exports.runStandardValidation = runStandardValidation;
+//# sourceMappingURL=types-C4Mgnku6.cjs.map