@palmares/schemas 0.1.25 → 0.1.26

package/dist/src/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,aAAa,EAAE,OAAO,aAAa,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,UAAU,IAAI;KAC7C,IAAI,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK;QACpE,IAAI,EAAE,cAAc,CAAC;QACrB,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,0BAA0B,CAAC,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;KAChF;CACF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;AAE3G;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,KAAK,CACf,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC;AAChC;;;;;;;;GAQG;AACH,KAAK,SAAS,OAAO,GAAG,QAAQ,GAAG,gBAAgB,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,IAEvF,OAAO,SAAS,MAAM,CACpB;IACE,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,SAAS,CAAC;IAC1B,MAAM,EAAE,MAAM,OAAO,CAAC;IACtB,cAAc,EAAE,MAAM,eAAe,CAAC;IACtC,QAAQ,EAAE,MAAM,SAAS,CAAC;CAC3B,EACD,GAAG,CACJ,GACG,KAAK,SAAS,QAAQ,GACpB,OAAO,GACP,KAAK,SAAS,gBAAgB,GAC5B,eAAe,GACf,KAAK,SAAS,UAAU,GACtB,SAAS,GACT,KAAK,SAAS,UAAU,GACtB,SAAS,GACT,MAAM,GACd,KAAK,CAAC"}

package/dist/src/utils.cjs

@@ -0,0 +1,477 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  WithFallback: () => WithFallback,
+  defaultTransform: () => defaultTransform,
+  defaultTransformToAdapter: () => defaultTransformToAdapter,
+  formatErrorFromParseMethod: () => formatErrorFromParseMethod,
+  parseErrorsFactory: () => parseErrorsFactory,
+  shouldRunDataOnComplexSchemas: () => shouldRunDataOnComplexSchemas,
+  transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas: () => transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas,
+  withFallbackFactory: () => withFallbackFactory
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/exceptions.ts
+var NoAdapterFoundError = class extends Error {
+  static {
+    __name(this, "NoAdapterFoundError");
+  }
+  constructor() {
+    super("No adapter found, please define an adapter using setDefaultAdapter() before using any schema.");
+  }
+};
+
+// src/conf.ts
+function getDefaultAdapter() {
+  if (!globalThis.$PSchemasAdapter) throw new NoAdapterFoundError();
+  return globalThis.$PSchemasAdapter;
+}
+__name(getDefaultAdapter, "getDefaultAdapter");
+
+// src/validators/schema.ts
+function optional(args) {
+  return {
+    name: "optional",
+    type: "high",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      if (value === void 0) {
+        if (args.allow === true) return {
+          parsed: value,
+          errors: [],
+          preventChildValidation: true
+        };
+        return {
+          parsed: value,
+          errors: [
+            {
+              isValid: false,
+              message: args.message,
+              code: "required",
+              // eslint-disable-next-line ts/no-unnecessary-condition
+              path: path || []
+            }
+          ],
+          preventChildValidation: true
+        };
+      }
+      return {
+        parsed: value,
+        errors: [],
+        preventChildValidation: false
+      };
+    }, "callback")
+  };
+}
+__name(optional, "optional");
+function nullable(args) {
+  return {
+    name: "nullable",
+    type: "high",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      if (value === null) {
+        if (args.allow === true) return {
+          parsed: value,
+          errors: [],
+          preventChildValidation: true
+        };
+        return {
+          parsed: value,
+          errors: [
+            {
+              isValid: false,
+              message: args.message,
+              code: "null",
+              // eslint-disable-next-line ts/no-unnecessary-condition
+              path: path || []
+            }
+          ],
+          preventChildValidation: true
+        };
+      }
+      return {
+        parsed: value,
+        errors: [],
+        preventChildValidation: false
+      };
+    }, "callback")
+  };
+}
+__name(nullable, "nullable");
+function checkType(args) {
+  return {
+    name: "checkType",
+    type: "medium",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      if (args.check(value)) return {
+        parsed: value,
+        errors: [],
+        preventChildValidation: false
+      };
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: false,
+            message: args.message,
+            code: "invalid_type",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || []
+          }
+        ],
+        preventChildValidation: true
+      };
+    }, "callback")
+  };
+}
+__name(checkType, "checkType");
+
+// src/validators/utils.ts
+var priorityByType = {
+  low: 0,
+  medium: 1,
+  high: 2
+};
+var typeByPriority = Object.entries(priorityByType).reduce((acc, [key, value]) => {
+  acc[value] = key;
+  return acc;
+}, {});
+var Validator = class _Validator {
+  static {
+    __name(this, "Validator");
+  }
+  $$type = "$PValidator";
+  child;
+  parent;
+  fallbackNamesAdded = /* @__PURE__ */ new Set();
+  priority;
+  fallbacks = [];
+  constructor(type) {
+    this.fallbackNamesAdded = /* @__PURE__ */ new Set();
+    this.fallbacks = [];
+    this.priority = priorityByType[type];
+  }
+  /**
+  * We create all of the validators on the schema in order, i actually didn't want to go on that route but i
+  * found it easier to do so.
+  *
+  * The logic here is simple, if it's not the same priority we will walk on the linked list until we find
+  * a validator that matches the priority we are expecting. If we can't walk anymore, we create the next
+  * priority validator and append it to the linked list. Be aware that it's a double linked list, so we
+  * can walk both ways, from the end to the start and from the start to the end.
+  * So you don't really need to start from the root, the linked list can start from anywhere and it will
+  * find it's way through.
+  *
+  * I know there are better ways to do this instead of walking through the linked list, but like i explained
+  * before, this is enough for now.
+  *
+  * If the priority is higher than the current priority saved on the schema, we should substitute the
+  * rootValidator on the schema with the new one.
+  *
+  * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific schema.
+  * @param type - The type of the fallback that we are adding.
+  * @param fallback - The fallback function that we are adding.
+  * @param childOrParent - If we are adding a fallback to the child or to the parent.
+  * @param options - The options that we are passing to the fallback.
+  */
+  checkAppendOrCreate(schema, type, fallbackName, fallback, childOrParent, options) {
+    const schemaWithProtected = schema;
+    if (this[childOrParent]) this[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
+    else {
+      const nextPriority = childOrParent === "child" ? this.priority - 1 : this.priority + 1;
+      if (Object.keys(typeByPriority).includes(String(nextPriority))) {
+        const nextType = typeByPriority[nextPriority];
+        const validatorInstance = new _Validator(nextType);
+        this[childOrParent] = validatorInstance;
+        this[childOrParent][childOrParent === "parent" ? "child" : "parent"] = this;
+        this[childOrParent].addFallback(schemaWithProtected, type, fallbackName, fallback, options);
+        if (nextPriority > schemaWithProtected.__rootFallbacksValidator.priority) schemaWithProtected.__rootFallbacksValidator = validatorInstance;
+      }
+    }
+  }
+  addFallback(schema, type, fallbackName, fallback, options) {
+    if (this.fallbackNamesAdded.has(fallbackName) && options?.removeCurrent !== true) return;
+    this.fallbackNamesAdded.add(fallbackName);
+    const priority = priorityByType[type];
+    if (this.priority === priority) {
+      if (typeof options?.at === "number") this.fallbacks.splice(options.at, options.removeCurrent === true ? 1 : 0, fallback);
+      else this.fallbacks.push(fallback);
+    } else if (priority > this.priority) this.checkAppendOrCreate(schema, type, fallbackName, fallback, "parent", options);
+    else if (priority < this.priority) this.checkAppendOrCreate(schema, type, fallbackName, fallback, "child", options);
+  }
+  /**
+  * Validates the value against all of the fallbacks, the fallbacks are executed in order, from the highest
+  * priority to the lowest priority. A validator can stop the execution of the other validators if it feels
+  * like so. Like on the example of a value being null or undefined.
+  *
+  * @param errorsAsHashedSet - This is a set that contains all of the errors that we already found, this is
+  * used to avoid duplicated errors.
+  * @param path - The path that we are validating right now.
+  * @param parseResult - The result of the parsing, it contains the parsed value and the errors that we found.
+  * @param options - The options that we are passing to the fallback.
+  */
+  async validate(errorsAsHashedSet, path, parseResult, options) {
+    let doesItShouldPreventChildValidation = false;
+    for (const fallback of this.fallbacks) {
+      const { parsed, errors, preventChildValidation } = await fallback(parseResult.parsed, path, options);
+      parseResult.parsed = parsed;
+      for (const error of errors) {
+        if (error.isValid === false) {
+          const sortedError = Object.fromEntries(Object.entries(error).sort(([a], [b]) => a.localeCompare(b)));
+          const hashedError = JSON.stringify(sortedError);
+          if (errorsAsHashedSet.has(hashedError)) continue;
+          errorsAsHashedSet.add(hashedError);
+          if (!Array.isArray(parseResult.errors)) parseResult.errors = [];
+          parseResult.errors.push({
+            ...error,
+            received: parseResult.parsed
+          });
+        }
+      }
+      doesItShouldPreventChildValidation = doesItShouldPreventChildValidation || preventChildValidation || false;
+    }
+    if (this.child && doesItShouldPreventChildValidation === false) return await this.child.validate(errorsAsHashedSet, path, parseResult, options);
+    return parseResult;
+  }
+  /**
+  * This static method takes care of everything for you. This means that you should only call this method
+  * for appending new fallbacks, it takes care of creating the root validator and making sure that the
+  * rootValidator on the schema is the highest priority one.
+  *
+  * @param schema - The schema that we are working on right now, all fallbacks are tied to that specific
+  * schema. We automatically define the rootValidator on the schema so you don't need to worry about that.
+  * @param fallback - The fallback that we are adding. This is an object that contains the type of the
+  * fallback and the callback that we are adding.
+  * @param options - The options that we are passing to the fallback. Options like `at` and `removeCurrent`
+  * are passed to the `addFallback` method.
+  */
+  static createAndAppendFallback(schema, fallback, options) {
+    const schemaWithProtected = schema;
+    let validatorInstance = schemaWithProtected.__rootFallbacksValidator;
+    if (schemaWithProtected.__rootFallbacksValidator === void 0) {
+      validatorInstance = new _Validator(fallback.type);
+      schemaWithProtected.__rootFallbacksValidator = validatorInstance;
+    }
+    validatorInstance.addFallback(schema, fallback.type, fallback.name, fallback.callback, options);
+    return validatorInstance;
+  }
+  toString(ident = 0) {
+    return `Priority: ${this.priority}
+Fallbacks: ${this.fallbacks.length}
+${this.child ? `Children:
+${this.child.toString(ident + 2)}` : ""}`;
+  }
+};
+
+// src/utils.ts
+var WithFallback = class {
+  static {
+    __name(this, "WithFallback");
+  }
+  $$type = "$PWithFallback";
+  fallbackFor;
+  transformedSchema;
+  adapterType;
+  constructor(adapterType, fallbackFor, transformedSchema) {
+    this.adapterType = adapterType;
+    this.fallbackFor = new Set(fallbackFor);
+    this.transformedSchema = transformedSchema;
+  }
+};
+function withFallbackFactory(adapterType) {
+  return (fallbackFor, transformedSchema) => new WithFallback(adapterType, fallbackFor, transformedSchema);
+}
+__name(withFallbackFactory, "withFallbackFactory");
+function parseErrorsFactory(schemaAdapter) {
+  return async (errorOrErrors, metadata) => {
+    const errorsIsAnArray = Array.isArray(errorOrErrors);
+    if (errorsIsAnArray) return Promise.all(errorOrErrors.map((error) => schemaAdapter.formatError.bind(schemaAdapter)(error, metadata)));
+    return [
+      await schemaAdapter.formatError.bind(schemaAdapter)(errorOrErrors, metadata)
+    ];
+  };
+}
+__name(parseErrorsFactory, "parseErrorsFactory");
+async function defaultTransform(type, schema, adapter, fieldAdapter, getValidationData, fallbackFunctions, options) {
+  const validationData = await Promise.resolve(getValidationData(false));
+  const validationDataForStringVersion = options.shouldAddStringVersion ? await Promise.resolve(getValidationData(true)) : void 0;
+  const schemaWithPrivateFields = schema;
+  const checkIfShouldUseParserAndAppend = /* @__PURE__ */ __name((parser) => {
+    const isValidationDataAParser = validationData.parsers?.[parser] !== void 0;
+    if (isValidationDataAParser) schema.__parsers._fallbacks.add(parser);
+  }, "checkIfShouldUseParserAndAppend");
+  const getExtendedOrNotSchemaAndString = /* @__PURE__ */ __name((schema2, toStringVersion) => {
+    const extendedOrNotSchema2 = typeof schemaWithPrivateFields.__extends?.callback === "function" ? schemaWithPrivateFields.__extends.callback(schema2) : schema2;
+    const extendedOrNotSchemaString2 = typeof schemaWithPrivateFields.__extends?.toStringCallback === "function" ? schemaWithPrivateFields.__extends.toStringCallback(toStringVersion) : toStringVersion;
+    return [
+      extendedOrNotSchema2,
+      extendedOrNotSchemaString2
+    ];
+  }, "getExtendedOrNotSchemaAndString");
+  const checkIfShouldAppendFallbackAndAppend = /* @__PURE__ */ __name((fallback) => {
+    const wereArgumentsForThatFallbackDefinedAndFallbackFunctionDefined = validationData[fallback] !== void 0 && fallbackFunctions[fallback] !== void 0;
+    if (wereArgumentsForThatFallbackDefinedAndFallbackFunctionDefined) {
+      const fallbackReturnType = fallbackFunctions[fallback](validationData[fallback]);
+      Validator.createAndAppendFallback(schema, fallbackReturnType);
+    }
+  }, "checkIfShouldAppendFallbackAndAppend");
+  const appendRootFallback = /* @__PURE__ */ __name(() => {
+    if (options.validatorsIfFallbackOrNotSupported) {
+      const validatorsIfFallbackOrNotSupported = Array.isArray(options.validatorsIfFallbackOrNotSupported) ? options.validatorsIfFallbackOrNotSupported : [
+        options.validatorsIfFallbackOrNotSupported
+      ];
+      for (const fallback of validatorsIfFallbackOrNotSupported) Validator.createAndAppendFallback(schema, fallback);
+    }
+  }, "appendRootFallback");
+  const appendRequiredFallbacks = /* @__PURE__ */ __name(() => {
+    const hasFallbacks = schemaWithPrivateFields.__rootFallbacksValidator?.["$$type"] === "$PValidator";
+    if (hasFallbacks) {
+      Validator.createAndAppendFallback(schema, optional(schemaWithPrivateFields.__optional));
+      Validator.createAndAppendFallback(schema, nullable(schemaWithPrivateFields.__nullable));
+      Validator.createAndAppendFallback(schema, checkType(schemaWithPrivateFields.__type));
+    }
+  }, "appendRequiredFallbacks");
+  const isFieldAdapterNotSupportedForThatFieldType = fieldAdapter === void 0;
+  if (options.fallbackIfNotSupported !== void 0 && isFieldAdapterNotSupportedForThatFieldType) {
+    const existingFallbacks = Object.keys(fallbackFunctions);
+    const allParsers = Object.keys(validationData["parsers"]);
+    appendRootFallback();
+    for (const fallback of existingFallbacks) checkIfShouldAppendFallbackAndAppend(fallback);
+    for (const parser of allParsers) checkIfShouldUseParserAndAppend(parser);
+    appendRequiredFallbacks();
+    return options.fallbackIfNotSupported();
+  }
+  if (!fieldAdapter) throw new Error("The field adapter is not supported and no fallback was provided.");
+  const translatedSchemaOrWithFallback = await Promise.resolve(fieldAdapter.translate(adapter.field, {
+    withFallback: withFallbackFactory(type),
+    ...validationData
+  }));
+  let stringVersion = "";
+  if (options.shouldAddStringVersion) stringVersion = await fieldAdapter.toString(adapter, adapter.field, validationDataForStringVersion);
+  if (translatedSchemaOrWithFallback?.["$$type"] === "$PWithFallback") {
+    appendRootFallback();
+    for (const fallback of translatedSchemaOrWithFallback.fallbackFor) {
+      checkIfShouldAppendFallbackAndAppend(fallback);
+      checkIfShouldUseParserAndAppend(fallback);
+    }
+    const [extendedOrNotSchema2, extendedOrNotSchemaString2] = getExtendedOrNotSchemaAndString(translatedSchemaOrWithFallback.transformedSchema, stringVersion);
+    appendRequiredFallbacks();
+    return [
+      {
+        transformed: extendedOrNotSchema2,
+        asString: extendedOrNotSchemaString2
+      }
+    ];
+  }
+  const [extendedOrNotSchema, extendedOrNotSchemaString] = getExtendedOrNotSchemaAndString(translatedSchemaOrWithFallback, stringVersion);
+  return [
+    {
+      transformed: extendedOrNotSchema,
+      asString: extendedOrNotSchemaString
+    }
+  ];
+}
+__name(defaultTransform, "defaultTransform");
+async function defaultTransformToAdapter(callback, schema, transformedSchemas, options, type) {
+  const isTransformedSchemasEmpty = Object.keys(transformedSchemas).length <= 0;
+  if (isTransformedSchemasEmpty) {
+    const adapterInstanceToUse = (
+      // eslint-disable-next-line ts/no-unnecessary-condition
+      options.schemaAdapter?.["$$type"] === "$PSchemaAdapter" ? options.schemaAdapter : getDefaultAdapter()
+    );
+    schema["__transformedSchemas"][adapterInstanceToUse.name] = {
+      transformed: false,
+      adapter: adapterInstanceToUse,
+      schemas: []
+    };
+  }
+  const schemaAdapterNameToUse = options.schemaAdapter?.name || Object.keys(transformedSchemas)[0];
+  const isACustomSchemaAdapterAndNotYetDefined = (
+    // eslint-disable-next-line ts/no-unnecessary-condition
+    transformedSchemas[schemaAdapterNameToUse] === void 0 && options.schemaAdapter !== void 0
+  );
+  if (isACustomSchemaAdapterAndNotYetDefined) transformedSchemas[schemaAdapterNameToUse] = {
+    transformed: false,
+    adapter: options.schemaAdapter,
+    schemas: []
+  };
+  const shouldTranslate = transformedSchemas[schemaAdapterNameToUse].transformed === false || options.force === true;
+  if (shouldTranslate) {
+    const translatedSchemas = await callback(transformedSchemas[schemaAdapterNameToUse].adapter);
+    transformedSchemas[schemaAdapterNameToUse].schemas = translatedSchemas;
+    transformedSchemas[schemaAdapterNameToUse].transformed = true;
+  }
+  transformedSchemas[schemaAdapterNameToUse].transformed = true;
+  return transformedSchemas[schemaAdapterNameToUse].schemas;
+}
+__name(defaultTransformToAdapter, "defaultTransformToAdapter");
+async function formatErrorFromParseMethod(adapter, fieldAdapter, error, received, schema, path, errorsAsHashedSet) {
+  const formattedError = await fieldAdapter.formatError(adapter, adapter.field, schema, error);
+  formattedError.path = Array.isArray(formattedError.path) ? [
+    ...path,
+    ...formattedError.path
+  ] : path;
+  const formattedErrorAsParseResultError = formattedError;
+  formattedErrorAsParseResultError.isValid = false;
+  const sortedError = Object.fromEntries(Object.entries(formattedErrorAsParseResultError).sort(([a], [b]) => a.localeCompare(b)));
+  const hashedError = JSON.stringify(sortedError);
+  errorsAsHashedSet.add(JSON.stringify(sortedError));
+  formattedErrorAsParseResultError.received = received;
+  return formattedErrorAsParseResultError;
+}
+__name(formatErrorFromParseMethod, "formatErrorFromParseMethod");
+async function transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas(schema, options) {
+  const schemaWithProtected = schema;
+  const transformedData = await schemaWithProtected.__transformToAdapter(options);
+  const doesKeyHaveFallback = schemaWithProtected.__rootFallbacksValidator !== void 0;
+  const doesKeyHaveToInternal = typeof schemaWithProtected.__toInternal === "function";
+  const doesKeyHaveToValidate = typeof schemaWithProtected.__toValidate === "function";
+  const doesKeyHaveToDefault = typeof schemaWithProtected.__defaultFunction === "function";
+  const doesKeyHaveRunBeforeParseAndData = typeof schemaWithProtected.__runBeforeParseAndData === "function";
+  const doesKeyHaveParserFallback = schemaWithProtected.__parsers._fallbacks.size > 0;
+  const shouldAddFallbackValidation = doesKeyHaveFallback || doesKeyHaveToInternal || doesKeyHaveToValidate || doesKeyHaveToDefault || doesKeyHaveParserFallback || doesKeyHaveRunBeforeParseAndData || // eslint-disable-next-line ts/no-unnecessary-condition
+  transformedData === void 0;
+  return [
+    transformedData,
+    shouldAddFallbackValidation
+  ];
+}
+__name(transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas, "transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas");
+function shouldRunDataOnComplexSchemas(schema) {
+  return schema["__parsers"].high.size > 0 || schema["__parsers"].medium.size > 0 || schema["__parsers"].low.size > 0 || schema["__parsers"]._fallbacks.size > 0 || typeof schema["__runBeforeParseAndData"] === "function" || typeof schema["__toRepresentation"] === "function" || typeof schema["__defaultFunction"] === "function";
+}
+__name(shouldRunDataOnComplexSchemas, "shouldRunDataOnComplexSchemas");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WithFallback,
+  defaultTransform,
+  defaultTransformToAdapter,
+  formatErrorFromParseMethod,
+  parseErrorsFactory,
+  shouldRunDataOnComplexSchemas,
+  transformSchemaAndCheckIfShouldBeHandledByFallbackOnComplexSchemas,
+  withFallbackFactory
+});

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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"}