@aeriajs/validation 0.0.26 → 0.0.28

package/dist/index.mjs

@@ -1 +1,2 @@
+"use strict";
 export * from "./validate.mjs";

package/dist/validate.mjs

@@ -1,258 +1,229 @@
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
+"use strict";
 import { isLeft, left, right, unwrapEither, getMissingProperties } from "@aeriajs/common";
 import { ValidationErrorCodes } from "@aeriajs/types";
-var getValueType = function(value) {
-    return Array.isArray(value) ? "array" : typeof value === "undefined" ? "undefined" : _type_of(value);
+const getValueType = (value) => {
+  return Array.isArray(value) ? "array" : typeof value;
 };
-var getPropertyType = function(property) {
-    if ("$ref" in property || "properties" in property || "additionalProperties" in property) {
-        return "object";
-    }
-    if ("enum" in property) {
-        return _type_of(property.enum[0]);
-    }
-    if ("format" in property && property.format) {
-        if ([
-            "date",
-            "date-time"
-        ].includes(property.format)) {
-            return "datetime";
-        }
-    }
-    if ("type" in property) {
-        return property.type;
-    }
+const getPropertyType = (property) => {
+  if ("$ref" in property || "properties" in property || "additionalProperties" in property) {
+    return "object";
+  }
+  if ("enum" in property) {
+    return typeof property.enum[0];
+  }
+  if ("format" in property && property.format) {
+    if ([
+      "date",
+      "date-time"
+    ].includes(property.format)) {
+      return "datetime";
+    }
+  }
+  if ("type" in property) {
+    return property.type;
+  }
 };
-var makePropertyError = function(type, details) {
-    return {
-        type: type,
-        details: details
-    };
+const makePropertyError = (type, details) => {
+  return {
+    type,
+    details
+  };
 };
-export var makeValidationError = function(error) {
-    return error;
+export const makeValidationError = (error) => {
+  return error;
 };
-export var validateProperty = function(propName, what, property) {
-    var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
-    var extraneous = options.extraneous, filterOutExtraneous = options.filterOutExtraneous, coerce = options.coerce;
-    if (what === undefined) {
-        return right(what);
-    }
-    if (!property) {
-        if (extraneous || Array.isArray(extraneous) && extraneous.includes(propName)) {
-            if (filterOutExtraneous) {
-                return right(undefined);
-            }
-            return right(what);
-        }
-        return left(makePropertyError("extraneous", {
-            expected: "undefined",
-            got: getValueType(what)
-        }));
-    }
-    if ("getter" in property) {
-        return right(undefined);
+export const validateProperty = (propName, what, property, options = {}) => {
+  const { extraneous, filterOutExtraneous, coerce } = options;
+  if (what === void 0) {
+    return right(what);
+  }
+  if (!property) {
+    if (extraneous || Array.isArray(extraneous) && extraneous.includes(propName)) {
+      if (filterOutExtraneous) {
+        return right(void 0);
+      }
+      return right(what);
+    }
+    return left(makePropertyError("extraneous", {
+      expected: "undefined",
+      got: getValueType(what)
+    }));
+  }
+  if ("getter" in property) {
+    return right(void 0);
+  }
+  if ("properties" in property) {
+    return validate(what, property, options);
+  }
+  if ("const" in property) {
+    if (what !== property.const) {
+      return left(makePropertyError("unmatching", {
+        expected: property.const,
+        got: what
+      }));
     }
-    if ("properties" in property) {
-        return validate(what, property, options);
+    return right(what);
+  }
+  const expectedType = getPropertyType(property);
+  const actualType = getValueType(what);
+  if ("enum" in property && property.enum.length === 0) {
+    return right(what);
+  }
+  if (actualType !== expectedType && !("items" in property && actualType === "array") && !(actualType === "number" && expectedType === "integer")) {
+    if (expectedType === "datetime" && what instanceof Date) {
+      return right(what);
     }
-    if ("const" in property) {
-        if (what !== property.const) {
-            return left(makePropertyError("unmatching", {
-                expected: property.const,
-                got: what
-            }));
-        }
-        return right(what);
+    if (expectedType === "boolean" && !what) {
+      return right(what);
     }
-    var expectedType = getPropertyType(property);
-    var actualType = getValueType(what);
-    if ("enum" in property && property.enum.length === 0) {
+    if ("$ref" in property && actualType === "string") {
+      if (/^[0-9a-fA-F]{24}$/.test(what)) {
         return right(what);
+      }
+    }
+    if (coerce) {
+      if (expectedType === "number" && actualType === "string") {
+        const coerced = parseFloat(what);
+        if (!isNaN(coerced)) {
+          return right(coerced);
+        }
+      }
+      if (expectedType === "integer" && actualType === "string") {
+        const coerced = parseInt(what);
+        if (!isNaN(coerced)) {
+          return right(coerced);
+        }
+      }
+      if (expectedType === "string" && actualType === "number") {
+        return right(String(what));
+      }
+    }
+    return left(makePropertyError("unmatching", {
+      expected: expectedType,
+      got: actualType
+    }));
+  }
+  if ("items" in property) {
+    let i = 0;
+    for (const elem of what) {
+      const resultEither = validateProperty(propName, elem, property.items, options);
+      if (isLeft(resultEither)) {
+        const result = unwrapEither(resultEither);
+        if ("errors" in result) {
+          continue;
+        }
+        result.index = i;
+        return left(result);
+      }
+      i++;
+    }
+  } else if ("type" in property) {
+    if (property.type === "integer") {
+      if (!Number.isInteger(what)) {
+        return left(makePropertyError("numeric_constraint", {
+          expected: "integer",
+          got: "invalid_number"
+        }));
+      }
     }
-    if (actualType !== expectedType && !("items" in property && actualType === "array") && !(actualType === "number" && expectedType === "integer")) {
-        if (expectedType === "datetime" && _instanceof(what, Date)) {
-            return right(what);
-        }
-        if (expectedType === "boolean" && !what) {
-            return right(what);
-        }
-        if ("$ref" in property && actualType === "string") {
-            if (/^[0-9a-fA-F]{24}$/.test(what)) {
-                return right(what);
-            }
-        }
-        if (coerce) {
-            if (expectedType === "number" && actualType === "string") {
-                var coerced = parseFloat(what);
-                if (!isNaN(coerced)) {
-                    return right(coerced);
-                }
-            }
-            if (expectedType === "integer" && actualType === "string") {
-                var coerced1 = parseInt(what);
-                if (!isNaN(coerced1)) {
-                    return right(coerced1);
-                }
-            }
-            if (expectedType === "string" && actualType === "number") {
-                return right(String(what));
-            }
-        }
-        return left(makePropertyError("unmatching", {
-            expected: expectedType,
-            got: actualType
+    if (property.type === "integer" || property.type === "number") {
+      if (property.maximum && property.maximum < what || property.minimum && property.minimum > what || property.exclusiveMaximum && property.exclusiveMaximum <= what || property.exclusiveMinimum && property.exclusiveMinimum >= what) {
+        return left(makePropertyError("numeric_constraint", {
+          expected: "number",
+          got: "invalid_number"
         }));
+      }
     }
-    if ("items" in property) {
-        var i = 0;
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = what[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var elem = _step.value;
-                var resultEither = validateProperty(propName, elem, property.items, options);
-                if (isLeft(resultEither)) {
-                    var result = unwrapEither(resultEither);
-                    if ("errors" in result) {
-                        continue;
-                    }
-                    result.index = i;
-                    return left(result);
-                }
-                i++;
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    } else if ("type" in property) {
-        if (property.type === "integer") {
-            if (!Number.isInteger(what)) {
-                return left(makePropertyError("numeric_constraint", {
-                    expected: "integer",
-                    got: "invalid_number"
-                }));
-            }
-        }
-        if (property.type === "integer" || property.type === "number") {
-            if (property.maximum && property.maximum < what || property.minimum && property.minimum > what || property.exclusiveMaximum && property.exclusiveMaximum <= what || property.exclusiveMinimum && property.exclusiveMinimum >= what) {
-                return left(makePropertyError("numeric_constraint", {
-                    expected: "number",
-                    got: "invalid_number"
-                }));
-            }
-        }
-    } else if ("enum" in property) {
-        if (!property.enum.includes(what)) {
-            return left(makePropertyError("extraneous_element", {
-                expected: property.enum,
-                got: what
-            }));
-        }
+  } else if ("enum" in property) {
+    if (!property.enum.includes(what)) {
+      return left(makePropertyError("extraneous_element", {
+        expected: property.enum,
+        got: what
+      }));
     }
-    return right(what);
+  }
+  return right(what);
 };
-export var validateWholeness = function(what, schema) {
-    var required = schema.required ? schema.required : Object.keys(schema.properties);
-    var missingProps = getMissingProperties(what, schema, required);
-    if (missingProps.length > 0) {
-        return makeValidationError({
-            code: ValidationErrorCodes.MissingProperties,
-            errors: Object.fromEntries(missingProps.map(function(error) {
-                return [
-                    error,
-                    {
-                        type: "missing"
-                    }
-                ];
-            }))
-        });
-    }
+export const validateWholeness = (what, schema) => {
+  const required = schema.required ? schema.required : Object.keys(schema.properties);
+  const missingProps = getMissingProperties(what, schema, required);
+  if (missingProps.length > 0) {
+    return makeValidationError({
+      code: ValidationErrorCodes.MissingProperties,
+      errors: Object.fromEntries(missingProps.map((error) => [
+        error,
+        {
+          type: "missing"
+        }
+      ]))
+    });
+  }
 };
-export var validate = function(what, schema) {
-    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    if (!what) {
-        return left(makeValidationError({
-            code: ValidationErrorCodes.EmptyTarget,
-            errors: {}
-        }));
-    }
-    if (!("properties" in schema)) {
-        var resultEither = validateProperty("", what, schema);
-        return isLeft(resultEither) ? resultEither : right(what);
-    }
-    var wholenessError = validateWholeness(what, schema);
-    if (wholenessError) {
-        return left(wholenessError);
-    }
-    var errors = {};
-    var resultCopy = {};
-    for(var propName in what){
-        var resultEither1 = validateProperty(propName, what[propName], schema.properties[propName], options);
-        if (isLeft(resultEither1)) {
-            var result = unwrapEither(resultEither1);
-            errors[propName] = result;
-        }
-        var parsed = unwrapEither(resultEither1);
-        if (parsed !== undefined) {
-            resultCopy[propName] = parsed;
-        }
-    }
-    if (Object.keys(errors).length > 0) {
-        if (options.throwOnError) {
-            var error = new TypeError(ValidationErrorCodes.InvalidProperties);
-            Object.assign(error, {
-                errors: errors
-            });
-            throw error;
-        }
-        return left(makeValidationError({
-            code: ValidationErrorCodes.InvalidProperties,
-            errors: errors
-        }));
-    }
-    return right(resultCopy);
+export const validate = (what, schema, options = {}) => {
+  if (!what) {
+    return left(makeValidationError({
+      code: ValidationErrorCodes.EmptyTarget,
+      errors: {}
+    }));
+  }
+  if (!("properties" in schema)) {
+    const resultEither = validateProperty("", what, schema);
+    return isLeft(resultEither) ? resultEither : right(what);
+  }
+  const wholenessError = validateWholeness(what, schema);
+  if (wholenessError) {
+    return left(wholenessError);
+  }
+  const errors = {};
+  const resultCopy = {};
+  for (const propName in what) {
+    const resultEither = validateProperty(
+      propName,
+      what[propName],
+      schema.properties[propName],
+      options
+    );
+    if (isLeft(resultEither)) {
+      const result = unwrapEither(resultEither);
+      errors[propName] = result;
+    }
+    const parsed = unwrapEither(resultEither);
+    if (parsed !== void 0) {
+      resultCopy[propName] = parsed;
+    }
+  }
+  if (Object.keys(errors).length > 0) {
+    if (options.throwOnError) {
+      const error = new TypeError(ValidationErrorCodes.InvalidProperties);
+      Object.assign(error, {
+        errors
+      });
+      throw error;
+    }
+    return left(makeValidationError({
+      code: ValidationErrorCodes.InvalidProperties,
+      errors
+    }));
+  }
+  return right(resultCopy);
 };
-export var validateSilently = function(what, schema) {
-    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    var resultEither = validate(what, schema, options);
-    return isLeft(resultEither) ? null : unwrapEither(resultEither);
+export const validateSilently = (what, schema, options = {}) => {
+  const resultEither = validate(what, schema, options);
+  return isLeft(resultEither) ? null : unwrapEither(resultEither);
 };
-export var validator = function(schema) {
-    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    return [
-        {},
-        function(what) {
-            return validate(what, schema, options);
-        }
-    ];
+export const validator = (schema, options = {}) => {
+  return [
+    {},
+    (what) => {
+      return validate(what, schema, options);
+    }
+  ];
 };
-export var silentValidator = function(schema) {
-    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    return [
-        {},
-        function(what) {
-            return validateSilently(what, schema, options);
-        }
-    ];
+export const silentValidator = (schema, options = {}) => {
+  return [
+    {},
+    (what) => {
+      return validateSilently(what, schema, options);
+    }
+  ];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/validation",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "## Installation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -22,8 +22,8 @@
     }
   },
   "peerDependencies": {
-    "@aeriajs/common": "^0.0.23",
-    "@aeriajs/types": "^0.0.20"
+    "@aeriajs/common": "^0.0.25",
+    "@aeriajs/types": "^0.0.22"
   },
   "scripts": {
     "test": "env TS_NODE_COMPILER_OPTIONS=\"$(cat ../compilerOptions.json)\" mocha -r ts-node/register tests/*.spec.ts",
@@ -31,7 +31,7 @@
     "lint:fix": "eslint src --fix",
     "build": "pnpm build:cjs && pnpm build:esm",
     "build:cjs": "tsc",
-    "build:esm": "swc src/* -d dist --strip-leading-paths -C module.type=es6 --out-file-extension=mjs && pnpm build:esm-transform",
+    "build:esm": "esbuild './src/**/*.ts' --outdir=dist --out-extension:.js=.mjs && pnpm build:esm-transform",
     "build:esm-transform": "pnpm -w esm-transform $PWD/dist"
   }
 }