@palmares/schemas 0.1.24 → 0.1.26

package/dist/src/validators/array.js

@@ -0,0 +1,150 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/validators/array.ts
+function arrayValidation(isTuple, schemas) {
+  return {
+    name: "array",
+    type: "medium",
+    callback: /* @__PURE__ */ __name(async (value, path, options) => {
+      const isNotAnArray = Array.isArray(value) === false;
+      if (isNotAnArray) return {
+        parsed: value,
+        preventChildValidation: true,
+        errors: [
+          {
+            isValid: false,
+            code: "array",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "The value must be an array. Received: " + typeof value
+          }
+        ]
+      };
+      if (isTuple && value.length !== schemas.length) return {
+        parsed: value,
+        preventChildValidation: true,
+        errors: [
+          {
+            isValid: false,
+            code: "tuple",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "The tuple must have exactly " + schemas.length + " elements. Received: " + value.length
+          }
+        ]
+      };
+      const errorsOfArray = [];
+      const schemaIndexByTypeof = /* @__PURE__ */ new Map();
+      let parsedValues = [];
+      parsedValues = await Promise.all(value.map(async (element, index) => {
+        let errorsToAppendAfterLoopIfNoSchemaMatched = [];
+        const typeofElement = typeof element;
+        const schemaIndex = schemaIndexByTypeof.get(typeofElement);
+        const existsASchemaIndex = typeof schemaIndex === "number";
+        const schemasToValidateAgainst = isTuple ? [
+          schemas[index]
+        ] : existsASchemaIndex ? [
+          schemas[schemaIndex]
+        ] : schemas;
+        for (let indexOfSchema = 0; indexOfSchema < schemasToValidateAgainst.length; indexOfSchema++) {
+          const schemaToValidate = schemasToValidateAgainst[indexOfSchema];
+          const schemaWithProtected = schemaToValidate;
+          const { parsed, errors } = await schemaWithProtected.__parse(element, [
+            ...path,
+            index
+          ], options);
+          if (schemaWithProtected.__toInternal && options.toInternalToBubbleUp) options.toInternalToBubbleUp.push(async () => parsedValues[indexOfSchema] = await schemaWithProtected.__toInternal?.(parsed));
+          if ((errors || []).length <= 0) {
+            errorsToAppendAfterLoopIfNoSchemaMatched = [];
+            schemaIndexByTypeof.set(typeofElement, indexOfSchema);
+            return parsed;
+          }
+          errorsToAppendAfterLoopIfNoSchemaMatched.push(...errors);
+        }
+        errorsOfArray.push(...errorsToAppendAfterLoopIfNoSchemaMatched);
+        return element;
+      }));
+      return {
+        parsed: parsedValues,
+        errors: errorsOfArray
+      };
+    }, "callback")
+  };
+}
+__name(arrayValidation, "arrayValidation");
+function minLength(args) {
+  return {
+    name: "minLength",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = args.inclusive ? value.length >= args.value : value.length > args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "minLength",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(minLength, "minLength");
+function maxLength(args) {
+  return {
+    name: "maxLength",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = args.inclusive ? value.length <= args.value : value.length < args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "maxLength",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(maxLength, "maxLength");
+function nonEmpty(args) {
+  return {
+    name: "nonEmpty",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = value.length > 0;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "nonEmpty",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(nonEmpty, "nonEmpty");
+export {
+  arrayValidation,
+  maxLength,
+  minLength,
+  nonEmpty
+};

package/dist/src/validators/boolean.cjs

@@ -0,0 +1,71 @@
+"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/validators/boolean.ts
+var boolean_exports = {};
+__export(boolean_exports, {
+  allowStringParser: () => allowStringParser,
+  booleanValidation: () => booleanValidation
+});
+module.exports = __toCommonJS(boolean_exports);
+function booleanValidation() {
+  return {
+    name: "boolean",
+    type: "medium",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = typeof value === "boolean";
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "boolean",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "Value is not a boolean"
+          }
+        ],
+        preventChildValidation: true
+      };
+    }, "callback")
+  };
+}
+__name(booleanValidation, "booleanValidation");
+function allowStringParser() {
+  return {
+    name: "allowString",
+    type: "high",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, _path, _options) => {
+      const parsed = Boolean(value);
+      return {
+        parsed,
+        errors: []
+      };
+    }, "callback")
+  };
+}
+__name(allowStringParser, "allowStringParser");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allowStringParser,
+  booleanValidation
+});

package/dist/src/validators/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src/validators/boolean.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAEpE,wBAAgB,iBAAiB,IAAI,4BAA4B,CA6BhE;AAED,wBAAgB,iBAAiB,IAAI,4BAA4B,CAiBhE"}

package/dist/src/validators/boolean.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/validators/boolean.ts
+function booleanValidation() {
+  return {
+    name: "boolean",
+    type: "medium",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = typeof value === "boolean";
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "boolean",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "Value is not a boolean"
+          }
+        ],
+        preventChildValidation: true
+      };
+    }, "callback")
+  };
+}
+__name(booleanValidation, "booleanValidation");
+function allowStringParser() {
+  return {
+    name: "allowString",
+    type: "high",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, _path, _options) => {
+      const parsed = Boolean(value);
+      return {
+        parsed,
+        errors: []
+      };
+    }, "callback")
+  };
+}
+__name(allowStringParser, "allowStringParser");
+export {
+  allowStringParser,
+  booleanValidation
+};

package/dist/src/validators/datetime.cjs

@@ -0,0 +1,129 @@
+"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/validators/datetime.ts
+var datetime_exports = {};
+__export(datetime_exports, {
+  above: () => above,
+  allowStringParser: () => allowStringParser,
+  below: () => below,
+  datetimeValidation: () => datetimeValidation
+});
+module.exports = __toCommonJS(datetime_exports);
+function datetimeValidation() {
+  return {
+    name: "datetime",
+    type: "medium",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = value instanceof Date && !isNaN(value.getTime());
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "datetime",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "Value is not a date"
+          }
+        ],
+        preventChildValidation: true
+      };
+    }, "callback")
+  };
+}
+__name(datetimeValidation, "datetimeValidation");
+function allowStringParser() {
+  return {
+    name: "allowString",
+    type: "high",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, _path, _options) => {
+      if (typeof value === "string") {
+        const parsed = new Date(value);
+        if (parsed instanceof Date && !isNaN(parsed.getTime())) {
+          return {
+            parsed,
+            errors: []
+          };
+        }
+      }
+      return {
+        parsed: value,
+        errors: []
+      };
+    }, "callback")
+  };
+}
+__name(allowStringParser, "allowStringParser");
+function below(args) {
+  return {
+    name: "below",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = args.inclusive ? value <= args.value : value < args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "below",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(below, "below");
+function above(args) {
+  return {
+    name: "above",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = args.inclusive ? value <= args.value : value < args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "above",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(above, "above");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  above,
+  allowStringParser,
+  below,
+  datetimeValidation
+});

package/dist/src/validators/datetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../../src/validators/datetime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAEpE,wBAAgB,kBAAkB,IAAI,4BAA4B,CA6BjE;AAED,wBAAgB,iBAAiB,IAAI,4BAA4B,CAyBhE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,4BAA4B,CA4BnF;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,4BAA4B,CA4BnF"}

package/dist/src/validators/datetime.js

@@ -0,0 +1,103 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/validators/datetime.ts
+function datetimeValidation() {
+  return {
+    name: "datetime",
+    type: "medium",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = value instanceof Date && !isNaN(value.getTime());
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "datetime",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "Value is not a date"
+          }
+        ],
+        preventChildValidation: true
+      };
+    }, "callback")
+  };
+}
+__name(datetimeValidation, "datetimeValidation");
+function allowStringParser() {
+  return {
+    name: "allowString",
+    type: "high",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, _path, _options) => {
+      if (typeof value === "string") {
+        const parsed = new Date(value);
+        if (parsed instanceof Date && !isNaN(parsed.getTime())) {
+          return {
+            parsed,
+            errors: []
+          };
+        }
+      }
+      return {
+        parsed: value,
+        errors: []
+      };
+    }, "callback")
+  };
+}
+__name(allowStringParser, "allowStringParser");
+function below(args) {
+  return {
+    name: "below",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = args.inclusive ? value <= args.value : value < args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "below",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(below, "below");
+function above(args) {
+  return {
+    name: "above",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      const isValid = args.inclusive ? value <= args.value : value < args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid: false,
+            code: "above",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(above, "above");
+export {
+  above,
+  allowStringParser,
+  below,
+  datetimeValidation
+};

package/dist/src/validators/number.cjs

@@ -0,0 +1,194 @@
+"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/validators/number.ts
+var number_exports = {};
+__export(number_exports, {
+  decimalPlaces: () => decimalPlaces,
+  integer: () => integer,
+  max: () => max,
+  maxDigits: () => maxDigits,
+  min: () => min,
+  numberValidation: () => numberValidation
+});
+module.exports = __toCommonJS(number_exports);
+function numberValidation() {
+  return {
+    name: "number",
+    type: "medium",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: typeof value === "number",
+            code: "number",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: "The value must be a number. Received: " + typeof value
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(numberValidation, "numberValidation");
+function max(args) {
+  return {
+    name: "max",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path, _options) => {
+      if (args.inclusive) return {
+        parsed: value,
+        errors: [
+          {
+            isValid: value <= args.value,
+            code: "max",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: value < args.value,
+            code: "max",
+            // eslint-disable-next-line ts/no-unnecessary-condition
+            path: path || [],
+            message: args.message
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(max, "max");
+function min(args) {
+  return {
+    name: "min",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      if (args.inclusive) return {
+        parsed: value,
+        errors: [
+          {
+            isValid: value >= args.value,
+            message: args.message,
+            code: "min",
+            path: path || []
+          }
+        ]
+      };
+      return {
+        parsed: value,
+        errors: [
+          {
+            isValid: value > args.value,
+            message: args.message,
+            code: "min",
+            path: path || []
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(min, "min");
+function integer(args) {
+  return {
+    name: "integer",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      const isValid = Number.isInteger(value);
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid,
+            message: args.message,
+            code: "integer",
+            path: path || []
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(integer, "integer");
+function maxDigits(args) {
+  return {
+    name: "maxDigits",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      const isValid = value.toString().replace(".", "").length <= args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid,
+            message: args.message,
+            code: "maxDigits",
+            path: path || []
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(maxDigits, "maxDigits");
+function decimalPlaces(args) {
+  return {
+    name: "decimalPlaces",
+    type: "low",
+    // eslint-disable-next-line ts/require-await
+    callback: /* @__PURE__ */ __name(async (value, path) => {
+      const isValid = value.toString().split(".")[1]?.length <= args.value;
+      return {
+        parsed: value,
+        errors: isValid ? [] : [
+          {
+            isValid,
+            message: args.message,
+            code: "decimalPlaces",
+            path: path || []
+          }
+        ]
+      };
+    }, "callback")
+  };
+}
+__name(decimalPlaces, "decimalPlaces");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decimalPlaces,
+  integer,
+  max,
+  maxDigits,
+  min,
+  numberValidation
+});