@decaf-ts/decorator-validation 1.5.2 → 1.5.5

package/lib/model/utils.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPropertyModel = isPropertyModel;
+exports.isModel = isModel;
+const constants_1 = require("../utils/constants.cjs");
+const Model_1 = require("./Model.cjs");
+function isPropertyModel(target, attribute) {
+    if (isModel(target[attribute]))
+        return true;
+    const metadata = Reflect.getMetadata(constants_1.ModelKeys.TYPE, target, attribute);
+    return Model_1.Model.get(metadata.name) ? metadata.name : undefined;
+}
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function isModel(target) {
+    try {
+        return target instanceof Model_1.Model || !!Model_1.Model.getMetadata(target);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        return false;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/model/utils.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "./Model";
+export declare function isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function isModel(target: Record<string, any>): boolean;

package/lib/model/validation.cjs

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+const ModelErrorDefinition_1 = require("./ModelErrorDefinition.cjs");
+const reflection_1 = require("@decaf-ts/reflection");
+const constants_1 = require("../utils/constants.cjs");
+const strings_1 = require("../utils/strings.cjs");
+const constants_2 = require("./constants.cjs");
+const Validation_1 = require("../validation/Validation.cjs");
+const constants_3 = require("../validation/Validators/constants.cjs");
+const utils_1 = require("./utils.cjs");
+/**
+ * @summary Analyses the decorations of the properties and validates the obj according to them
+ *
+ * @typedef T extends Model
+ * @prop {T} obj Model object to validate
+ * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ *
+ * @function validate
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function validate(obj, ...propsToIgnore) {
+    const decoratedProperties = [];
+    for (const prop in obj)
+        if (Object.prototype.hasOwnProperty.call(obj, prop) &&
+            propsToIgnore.indexOf(prop) === -1)
+            decoratedProperties.push(reflection_1.Reflection.getPropertyDecorators(constants_3.ValidationKeys.REFLECT, obj, prop));
+    let result = undefined;
+    for (const decoratedProperty of decoratedProperties) {
+        const { prop, decorators } = decoratedProperty;
+        if (!decorators || !decorators.length)
+            continue;
+        const defaultTypeDecorator = decorators[0];
+        // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification
+        if (decorators.find((d) => {
+            if (d.key === constants_3.ValidationKeys.TYPE)
+                return true;
+            return !!d.props.types?.find((t) => t === defaultTypeDecorator.props.name);
+        })) {
+            decorators.shift(); // remove the design:type decorator, since the type will already be checked
+        }
+        let errs = undefined;
+        for (const decorator of decorators) {
+            const validator = Validation_1.Validation.get(decorator.key);
+            if (!validator) {
+                throw new Error(`Missing validator for ${decorator.key}`);
+            }
+            const decoratorProps = decorator.key === constants_1.ModelKeys.TYPE
+                ? [decorator.props]
+                : (decorator.props || {});
+            const err = validator.hasErrors(obj[prop.toString()], decoratorProps);
+            if (err) {
+                errs = errs || {};
+                errs[decorator.key] = err;
+            }
+        }
+        if (errs) {
+            result = result || {};
+            result[decoratedProperty.prop.toString()] = errs;
+        }
+    }
+    // tests nested classes
+    for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {
+        let err;
+        // if a nested Model
+        const allDecorators = reflection_1.Reflection.getPropertyDecorators(constants_3.ValidationKeys.REFLECT, obj, prop).decorators;
+        const decorators = reflection_1.Reflection.getPropertyDecorators(constants_3.ValidationKeys.REFLECT, obj, prop).decorators.filter((d) => [constants_1.ModelKeys.TYPE, constants_3.ValidationKeys.TYPE].indexOf(d.key) !== -1);
+        if (!decorators || !decorators.length)
+            continue;
+        const dec = decorators.pop();
+        const clazz = dec.props.name
+            ? [dec.props.name]
+            : Array.isArray(dec.props.customTypes)
+                ? dec.props.customTypes
+                : [dec.props.customTypes];
+        const reserved = Object.values(constants_2.ReservedModels).map((v) => v.toLowerCase());
+        for (const c of clazz) {
+            if (reserved.indexOf(c.toLowerCase()) === -1) {
+                const typeDecoratorKey = Array.isArray(obj[prop])
+                    ? constants_3.ValidationKeys.LIST
+                    : constants_3.ValidationKeys.TYPE;
+                const types = allDecorators.find((d) => d.key === typeDecoratorKey) || {};
+                let allowedTypes = [];
+                if (types && types.props) {
+                    const customTypes = Array.isArray(obj[prop])
+                        ? types.props.class
+                        : types.props.customTypes;
+                    if (customTypes)
+                        allowedTypes = Array.isArray(customTypes)
+                            ? customTypes.map((t) => `${t}`.toLowerCase())
+                            : [customTypes.toLowerCase()];
+                }
+                const validate = (prop, value) => {
+                    if (typeof value === "object" || typeof value === "function")
+                        return (0, utils_1.isModel)(value)
+                            ? value.hasErrors()
+                            : allowedTypes.includes(typeof value)
+                                ? undefined
+                                : "Value has no validatable type";
+                };
+                switch (c) {
+                    case Array.name:
+                    case Set.name:
+                        if (allDecorators.length) {
+                            const listDec = allDecorators.find((d) => d.key === constants_3.ValidationKeys.LIST);
+                            if (listDec) {
+                                err = (c === Array.name
+                                    ? obj[prop]
+                                    : // If it's a Set
+                                        obj[prop].values())
+                                    .map((v) => validate(prop, v))
+                                    .filter((e) => !!e);
+                                if (!err?.length) {
+                                    // if the result is an empty list...
+                                    err = undefined;
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        try {
+                            if (obj[prop])
+                                err = validate(prop, obj[prop]);
+                        }
+                        catch (e) {
+                            console.warn((0, strings_1.sf)("Model should be validatable but its not: " + e));
+                        }
+                }
+            }
+            if (err) {
+                result = result || {};
+                result[prop] = err;
+            }
+        }
+    }
+    return result ? new ModelErrorDefinition_1.ModelErrorDefinition(result) : undefined;
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/validation.ts"],"names":[],"mappings":"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","file":"model/validation.js","sourcesContent":["import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ReservedModels } from \"./constants\";\nimport { Validatable } from \"./types\";\nimport { Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n} from \"../validation/types\";\nimport { isModel } from \"./utils\";\nimport type { ValidatorOptions } from \"../validation\";\n\n/**\n * @summary Analyses the decorations of the properties and validates the obj according to them\n *\n * @typedef T extends Model\n * @prop {T} obj Model object to validate\n * @prop {string[]} [propsToIgnore] object properties to ignore in the validation\n *\n * @function validate\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function validate<T extends Model>(\n  obj: T,\n  ...propsToIgnore: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in obj)\n    if (\n      Object.prototype.hasOwnProperty.call(obj, prop) &&\n      propsToIgnore.indexOf(prop) === -1\n    )\n      decoratedProperties.push(\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\n      );\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    if (!decorators || !decorators.length) continue;\n\n    const defaultTypeDecorator: DecoratorMetadata = decorators[0];\n\n    // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification\n    if (\n      decorators.find((d) => {\n        if (d.key === ValidationKeys.TYPE) return true;\n        return !!d.props.types?.find(\n          (t) => t === defaultTypeDecorator.props.name\n        );\n      })\n    ) {\n      decorators.shift(); // remove the design:type decorator, since the type will already be checked\n    }\n\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator = Validation.get(decorator.key);\n      if (!validator) {\n        throw new Error(`Missing validator for ${decorator.key}`);\n      }\n\n      const decoratorProps = decorator.key === ModelKeys.TYPE\n        ? [decorator.props]\n        : (decorator.props || {});\n\n      const err: string | undefined = validator.hasErrors(\n        (obj as any)[prop.toString()],\n        decoratorProps as ValidatorOptions\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n\n  // tests nested classes\n  for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators;\n    const decorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators.filter(\n      (d: { key: string }) =>\n        [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\n    const dec = decorators.pop() as DecoratorMetadata;\n    const clazz = dec.props.name\n      ? [dec.props.name]\n      : Array.isArray(dec.props.customTypes)\n        ? dec.props.customTypes\n        : [dec.props.customTypes];\n    const reserved = Object.values(ReservedModels).map((v) =>\n      v.toLowerCase()\n    ) as string[];\n\n    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        const typeDecoratorKey = Array.isArray((obj as any)[prop])\n          ? ValidationKeys.LIST\n          : ValidationKeys.TYPE;\n        const types: any =\n          allDecorators.find(\n            (d: { key: string }) => d.key === typeDecoratorKey\n          ) || {};\n        let allowedTypes: string[] = [];\n        if (types && types.props) {\n          const customTypes = Array.isArray((obj as any)[prop])\n            ? types.props.class\n            : types.props.customTypes;\n          if (customTypes)\n            allowedTypes = Array.isArray(customTypes)\n              ? customTypes.map((t) => `${t}`.toLowerCase())\n              : [customTypes.toLowerCase()];\n        }\n\n        const validate = (prop: string, value: any): any => {\n          if (typeof value === \"object\" || typeof value === \"function\")\n            return isModel(value)\n              ? (value as Model).hasErrors()\n              : allowedTypes.includes(typeof value)\n                ? undefined\n                : \"Value has no validatable type\";\n        };\n\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d: { key: string }) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                err = (\n                  c === Array.name\n                    ? (obj as Record<string, any>)[prop]\n                    : // If it's a Set\n                      (obj as Record<string, any>)[prop].values()\n                )\n                  .map((v: Validatable) => validate(prop, v))\n                  .filter((e: any) => !!e) as any;\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if ((obj as Record<string, any>)[prop])\n                err = validate(prop, (obj as any)[prop]);\n            } catch (e: any) {\n              console.warn(sf(\"Model should be validatable but its not: \" + e));\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n"]}

package/lib/model/validation.d.ts

@@ -0,0 +1,14 @@
+import { ModelErrorDefinition } from "./ModelErrorDefinition";
+import { Model } from "./Model";
+/**
+ * @summary Analyses the decorations of the properties and validates the obj according to them
+ *
+ * @typedef T extends Model
+ * @prop {T} obj Model object to validate
+ * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ *
+ * @function validate
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function validate<T extends Model>(obj: T, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;

package/lib/utils/constants.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelKeys = void 0;
+/**
+ * @summary Defines the various Model keys used for reflection
+ *
+ * @property {string} REFLECT prefix to all other keys
+ * @property {string} TYPE type key
+ * @property {string} PARAMS method params key
+ * @property {string} RETURN method return key
+ * @property {string} MODEL model key
+ * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
+ *
+ * @constant ModelKeys
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+var ModelKeys;
+(function (ModelKeys) {
+    ModelKeys["REFLECT"] = "decaf.model.";
+    ModelKeys["TYPE"] = "design:type";
+    ModelKeys["PARAMS"] = "design:paramtypes";
+    ModelKeys["RETURN"] = "design:returntype";
+    ModelKeys["MODEL"] = "model";
+    ModelKeys["ANCHOR"] = "__model";
+    ModelKeys["CONSTRUCTION"] = "constructed-by";
+    ModelKeys["ATTRIBUTE"] = "__attributes";
+    ModelKeys["HASHING"] = "hashing";
+    ModelKeys["SERIALIZATION"] = "serialization";
+})(ModelKeys || (exports.ModelKeys = ModelKeys = {}));
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILElBQVksU0FXWDtBQVhELFdBQVksU0FBUztJQUNuQixxQ0FBd0IsQ0FBQTtJQUN4QixpQ0FBb0IsQ0FBQTtJQUNwQix5Q0FBNEIsQ0FBQTtJQUM1Qix5Q0FBNEIsQ0FBQTtJQUM1Qiw0QkFBZSxDQUFBO0lBQ2YsK0JBQWtCLENBQUE7SUFDbEIsNENBQStCLENBQUE7SUFDL0IsdUNBQTBCLENBQUE7SUFDMUIsZ0NBQW1CLENBQUE7SUFDbkIsNENBQStCLENBQUE7QUFDakMsQ0FBQyxFQVhXLFNBQVMseUJBQVQsU0FBUyxRQVdwQiIsImZpbGUiOiJ1dGlscy9jb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBzdW1tYXJ5IERlZmluZXMgdGhlIHZhcmlvdXMgTW9kZWwga2V5cyB1c2VkIGZvciByZWZsZWN0aW9uXG4gKlxuICogQHByb3BlcnR5IHtzdHJpbmd9IFJFRkxFQ1QgcHJlZml4IHRvIGFsbCBvdGhlciBrZXlzXG4gKiBAcHJvcGVydHkge3N0cmluZ30gVFlQRSB0eXBlIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFBBUkFNUyBtZXRob2QgcGFyYW1zIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFJFVFVSTiBtZXRob2QgcmV0dXJuIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IE1PREVMIG1vZGVsIGtleVxuICogQHByb3BlcnR5IHtzdHJpbmd9IEFOQ0hPUiBhbmNob3Iga2V5LiB3aWxsIHNlcnZlIGFzIGEgZ2hvc3QgcHJvcGVydHkgaW4gdGhlIG1vZGVsXG4gKlxuICogQGNvbnN0YW50IE1vZGVsS2V5c1xuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0b3ItdmFsaWRhdGlvbi5Nb2RlbFxuICogQGNhdGVnb3J5IE1vZGVsXG4gKi9cbmV4cG9ydCBlbnVtIE1vZGVsS2V5cyB7XG4gIFJFRkxFQ1QgPSBcImRlY2FmLm1vZGVsLlwiLFxuICBUWVBFID0gXCJkZXNpZ246dHlwZVwiLFxuICBQQVJBTVMgPSBcImRlc2lnbjpwYXJhbXR5cGVzXCIsXG4gIFJFVFVSTiA9IFwiZGVzaWduOnJldHVybnR5cGVcIixcbiAgTU9ERUwgPSBcIm1vZGVsXCIsXG4gIEFOQ0hPUiA9IFwiX19tb2RlbFwiLFxuICBDT05TVFJVQ1RJT04gPSBcImNvbnN0cnVjdGVkLWJ5XCIsXG4gIEFUVFJJQlVURSA9IFwiX19hdHRyaWJ1dGVzXCIsXG4gIEhBU0hJTkcgPSBcImhhc2hpbmdcIixcbiAgU0VSSUFMSVpBVElPTiA9IFwic2VyaWFsaXphdGlvblwiLFxufVxuIl19

package/lib/utils/constants.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @summary Defines the various Model keys used for reflection
+ *
+ * @property {string} REFLECT prefix to all other keys
+ * @property {string} TYPE type key
+ * @property {string} PARAMS method params key
+ * @property {string} RETURN method return key
+ * @property {string} MODEL model key
+ * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
+ *
+ * @constant ModelKeys
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+export declare enum ModelKeys {
+    REFLECT = "decaf.model.",
+    TYPE = "design:type",
+    PARAMS = "design:paramtypes",
+    RETURN = "design:returntype",
+    MODEL = "model",
+    ANCHOR = "__model",
+    CONSTRUCTION = "constructed-by",
+    ATTRIBUTE = "__attributes",
+    HASHING = "hashing",
+    SERIALIZATION = "serialization"
+}

package/lib/utils/dates.cjs

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFromFormat = dateFromFormat;
+exports.bindDateToString = bindDateToString;
+exports.isValidDate = isValidDate;
+exports.twoDigitPad = twoDigitPad;
+exports.formatDate = formatDate;
+exports.parseDate = parseDate;
+require("reflect-metadata");
+const constants_1 = require("../validation/Validators/constants.cjs");
+const strings_1 = require("./strings.cjs");
+/**
+ * @summary Reverses the process from {@link formatDate}
+ *
+ * @param {string} date the date string to be converted back into date
+ * @param {string} format the date format
+ * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)
+ *
+ * @function dateFromFormat
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+function dateFromFormat(date, format) {
+    let formatRegexp = format;
+    // Hour
+    if (formatRegexp.match(/hh/))
+        formatRegexp = formatRegexp.replace("hh", "(?<hour>\\d{2})");
+    else if (formatRegexp.match(/h/))
+        formatRegexp = formatRegexp.replace("h", "(?<hour>\\d{1,2})");
+    else if (formatRegexp.match(/HH/))
+        formatRegexp = formatRegexp.replace("HH", "(?<hour>\\d{2})");
+    else if (formatRegexp.match(/H/))
+        formatRegexp = formatRegexp.replace("H", "(?<hour>\\d{1,2})");
+    // Minutes
+    if (formatRegexp.match(/mm/))
+        formatRegexp = formatRegexp.replace("mm", "(?<minutes>\\d{2})");
+    else if (formatRegexp.match(/m/))
+        formatRegexp = formatRegexp.replace("m", "(?<minutes>\\d{1,2})");
+    // Seconds
+    if (formatRegexp.match(/ss/))
+        formatRegexp = formatRegexp.replace("ss", "(?<seconds>\\d{2})");
+    else if (formatRegexp.match(/s/))
+        formatRegexp = formatRegexp.replace("s", "(?<seconds>\\d{1,2})");
+    // Day
+    if (formatRegexp.match(/dd/))
+        formatRegexp = formatRegexp.replace("dd", "(?<day>\\d{2})");
+    else if (formatRegexp.match(/d/))
+        formatRegexp = formatRegexp.replace("d", "(?<day>\\d{1,2})");
+    // Day Of Week
+    if (formatRegexp.match(/EEEE/))
+        formatRegexp = formatRegexp.replace("EEEE", "(?<dayofweek>\\w+)");
+    // eslint-disable-next-line no-dupe-else-if
+    else if (formatRegexp.match(/EEEE/))
+        formatRegexp = formatRegexp.replace("EEE", "(?<dayofweek>\\w+)");
+    // Year
+    if (formatRegexp.match(/yyyy/))
+        formatRegexp = formatRegexp.replace("yyyy", "(?<year>\\d{4})");
+    else if (formatRegexp.match(/yy/))
+        formatRegexp = formatRegexp.replace("yy", "(?<year>\\d{2})");
+    // Month
+    if (formatRegexp.match(/MMMM/))
+        formatRegexp = formatRegexp.replace("MMMM", "(?<monthname>\\w+)");
+    else if (formatRegexp.match(/MMM/))
+        formatRegexp = formatRegexp.replace("MMM", "(?<monthnamesmall>\\w+)");
+    if (formatRegexp.match(/MM/))
+        formatRegexp = formatRegexp.replace("MM", "(?<month>\\d{2})");
+    else if (formatRegexp.match(/M/))
+        formatRegexp = formatRegexp.replace("M", "(?<month>\\d{1,2})");
+    // Milis and Am Pm
+    formatRegexp = formatRegexp
+        .replace("S", "(?<milis>\\d{1,3})")
+        .replace("aaa", "(?<ampm>\\w{2})");
+    const regexp = new RegExp(formatRegexp, "g");
+    const match = regexp.exec(date);
+    if (!match || !match.groups)
+        return new Date(date);
+    const safeParseInt = function (n) {
+        if (!n)
+            return 0;
+        const result = parseInt(n);
+        return isNaN(result) ? 0 : result;
+    };
+    const year = safeParseInt(match.groups.year);
+    const day = safeParseInt(match.groups.day);
+    const amPm = match.groups.ampm;
+    let hour = safeParseInt(match.groups.hour);
+    if (amPm)
+        hour = amPm === "PM" ? hour + 12 : hour;
+    const minutes = safeParseInt(match.groups.minutes);
+    const seconds = safeParseInt(match.groups.seconds);
+    const ms = safeParseInt(match.groups.milis);
+    const monthName = match.groups.monthname;
+    const monthNameSmall = match.groups.monthnamesmall;
+    let month = match.groups.month;
+    if (monthName)
+        month = constants_1.MONTH_NAMES.indexOf(monthName);
+    else if (monthNameSmall) {
+        const m = constants_1.MONTH_NAMES.find((m) => m.toLowerCase().startsWith(monthNameSmall.toLowerCase()));
+        if (!m)
+            return new Date(date);
+        month = constants_1.MONTH_NAMES.indexOf(m);
+    }
+    else
+        month = safeParseInt(`${month}`);
+    return new Date(year, month - 1, day, hour, minutes, seconds, ms);
+}
+/**
+ * @summary Binds a date format to a string
+ * @param {Date} [date]
+ * @param {string} [format]
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Utilities
+ */
+function bindDateToString(date, format) {
+    if (!date)
+        return;
+    const func = () => formatDate(date, format);
+    Object.defineProperty(date, "toISOString", {
+        enumerable: false,
+        configurable: false,
+        value: func,
+    });
+    Object.defineProperty(date, "toString", {
+        enumerable: false,
+        configurable: false,
+        value: func,
+    });
+    // Object.setPrototypeOf(date, Date.prototype);
+    return date;
+}
+/**
+ * @summary Helper function to be used instead of instanceOf Date
+ * @param date
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Validation
+ */
+function isValidDate(date) {
+    return (date &&
+        Object.prototype.toString.call(date) === "[object Date]" &&
+        !Number.isNaN(date));
+}
+/**
+ * @summary Util function to pad numbers
+ * @param {number} num
+ *
+ * @return {string}
+ *
+ * @function twoDigitPad
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+function twoDigitPad(num) {
+    return num < 10 ? "0" + num : num.toString();
+}
+/**
+ * @summary Date Format Handling
+ * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}
+ *
+ * <pre>
+ *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
+ *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
+ *      You can display date, time, AM/PM, etc.
+ *
+ *      Date and Time Patterns
+ *      yy = 2-digit year; yyyy = full year
+ *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
+ *      EEEE = full weekday name; EEE = short weekday name
+ *      d = digit day; dd = 2-digit day
+ *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
+ *      m = minutes; mm = 2-digit minutes; aaa = AM/PM
+ *      s = seconds; ss = 2-digit seconds
+ *      S = miliseconds
+ * </pre>
+ *
+ * @param {Date} date
+ * @param {string} [patternStr] defaults to 'yyyy/MM/dd'
+ * @return {string} the formatted date
+ *
+ * @function formatDate
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+function formatDate(date, patternStr = "yyyy/MM/dd") {
+    const day = date.getDate(), month = date.getMonth(), year = date.getFullYear(), hour = date.getHours(), minute = date.getMinutes(), second = date.getSeconds(), miliseconds = date.getMilliseconds(), h = hour % 12, hh = twoDigitPad(h), HH = twoDigitPad(hour), mm = twoDigitPad(minute), ss = twoDigitPad(second), aaa = hour < 12 ? "AM" : "PM", EEEE = constants_1.DAYS_OF_WEEK_NAMES[date.getDay()], EEE = EEEE.substr(0, 3), dd = twoDigitPad(day), M = month + 1, MM = twoDigitPad(M), MMMM = constants_1.MONTH_NAMES[month], MMM = MMMM.substr(0, 3), yyyy = year + "", yy = yyyy.substr(2, 2);
+    // checks to see if month name will be used
+    patternStr = patternStr
+        .replace("hh", hh)
+        .replace("h", h.toString())
+        .replace("HH", HH)
+        .replace("H", hour.toString())
+        .replace("mm", mm)
+        .replace("m", minute.toString())
+        .replace("ss", ss)
+        .replace("s", second.toString())
+        .replace("S", miliseconds.toString())
+        .replace("dd", dd)
+        .replace("d", day.toString())
+        .replace("EEEE", EEEE)
+        .replace("EEE", EEE)
+        .replace("yyyy", yyyy)
+        .replace("yy", yy)
+        .replace("aaa", aaa);
+    if (patternStr.indexOf("MMM") > -1) {
+        patternStr = patternStr.replace("MMMM", MMMM).replace("MMM", MMM);
+    }
+    else {
+        patternStr = patternStr.replace("MM", MM).replace("M", M.toString());
+    }
+    return patternStr;
+}
+/**
+ * @summary Parses a date from a specified format
+ * @param {string} format
+ * @param {string | Date | number} [v]
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+function parseDate(format, v) {
+    let value = undefined;
+    if (!v)
+        return undefined;
+    if (v instanceof Date)
+        try {
+            value = dateFromFormat(formatDate(v, format), format);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            throw new Error((0, strings_1.sf)("Could not convert date {0} to format: {1}", v.toString(), format));
+        }
+    else if (typeof v === "string") {
+        value = dateFromFormat(v, format);
+    }
+    else if (typeof v === "number") {
+        const d = new Date(v);
+        value = dateFromFormat(formatDate(d, format), format);
+    }
+    else if (isValidDate(v)) {
+        try {
+            const d = new Date(v);
+            value = dateFromFormat(formatDate(d, format), format);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            throw new Error((0, strings_1.sf)("Could not convert date {0} to format: {1}", v, format));
+        }
+    }
+    else {
+        throw new Error(`Invalid value provided ${v}`);
+    }
+    return bindDateToString(value, format);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/dates.ts"],"names":[],"mappings":"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","file":"utils/dates.js","sourcesContent":["import \"reflect-metadata\";\nimport {\n  DAYS_OF_WEEK_NAMES,\n  MONTH_NAMES,\n} from \"../validation/Validators/constants\";\nimport { sf } from \"./strings\";\n\n/**\n * @summary Reverses the process from {@link formatDate}\n *\n * @param {string} date the date string to be converted back into date\n * @param {string} format the date format\n * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)\n *\n * @function dateFromFormat\n * @memberOf module:decorator-validation.Utils.Dates\n * @category Format\n */\nexport function dateFromFormat(date: string, format: string) {\n  let formatRegexp: string = format;\n\n  // Hour\n  if (formatRegexp.match(/hh/))\n    formatRegexp = formatRegexp.replace(\"hh\", \"(?<hour>\\\\d{2})\");\n  else if (formatRegexp.match(/h/))\n    formatRegexp = formatRegexp.replace(\"h\", \"(?<hour>\\\\d{1,2})\");\n  else if (formatRegexp.match(/HH/))\n    formatRegexp = formatRegexp.replace(\"HH\", \"(?<hour>\\\\d{2})\");\n  else if (formatRegexp.match(/H/))\n    formatRegexp = formatRegexp.replace(\"H\", \"(?<hour>\\\\d{1,2})\");\n\n  // Minutes\n  if (formatRegexp.match(/mm/))\n    formatRegexp = formatRegexp.replace(\"mm\", \"(?<minutes>\\\\d{2})\");\n  else if (formatRegexp.match(/m/))\n    formatRegexp = formatRegexp.replace(\"m\", \"(?<minutes>\\\\d{1,2})\");\n\n  // Seconds\n  if (formatRegexp.match(/ss/))\n    formatRegexp = formatRegexp.replace(\"ss\", \"(?<seconds>\\\\d{2})\");\n  else if (formatRegexp.match(/s/))\n    formatRegexp = formatRegexp.replace(\"s\", \"(?<seconds>\\\\d{1,2})\");\n\n  // Day\n  if (formatRegexp.match(/dd/))\n    formatRegexp = formatRegexp.replace(\"dd\", \"(?<day>\\\\d{2})\");\n  else if (formatRegexp.match(/d/))\n    formatRegexp = formatRegexp.replace(\"d\", \"(?<day>\\\\d{1,2})\");\n\n  // Day Of Week\n  if (formatRegexp.match(/EEEE/))\n    formatRegexp = formatRegexp.replace(\"EEEE\", \"(?<dayofweek>\\\\w+)\");\n  // eslint-disable-next-line no-dupe-else-if\n  else if (formatRegexp.match(/EEEE/))\n    formatRegexp = formatRegexp.replace(\"EEE\", \"(?<dayofweek>\\\\w+)\");\n\n  // Year\n  if (formatRegexp.match(/yyyy/))\n    formatRegexp = formatRegexp.replace(\"yyyy\", \"(?<year>\\\\d{4})\");\n  else if (formatRegexp.match(/yy/))\n    formatRegexp = formatRegexp.replace(\"yy\", \"(?<year>\\\\d{2})\");\n\n  // Month\n  if (formatRegexp.match(/MMMM/))\n    formatRegexp = formatRegexp.replace(\"MMMM\", \"(?<monthname>\\\\w+)\");\n  else if (formatRegexp.match(/MMM/))\n    formatRegexp = formatRegexp.replace(\"MMM\", \"(?<monthnamesmall>\\\\w+)\");\n  if (formatRegexp.match(/MM/))\n    formatRegexp = formatRegexp.replace(\"MM\", \"(?<month>\\\\d{2})\");\n  else if (formatRegexp.match(/M/))\n    formatRegexp = formatRegexp.replace(\"M\", \"(?<month>\\\\d{1,2})\");\n\n  // Milis and Am Pm\n  formatRegexp = formatRegexp\n    .replace(\"S\", \"(?<milis>\\\\d{1,3})\")\n    .replace(\"aaa\", \"(?<ampm>\\\\w{2})\");\n\n  const regexp = new RegExp(formatRegexp, \"g\");\n\n  const match: {\n    groups: {\n      year?: string;\n      day?: string;\n      ampm?: string;\n      hour?: string;\n      minutes?: string;\n      seconds?: string;\n      milis?: string;\n      monthname?: string;\n      monthnamesmall?: string;\n      month?: string;\n    };\n  } = regexp.exec(date) as any;\n\n  if (!match || !match.groups) return new Date(date);\n\n  const safeParseInt = function (n?: string) {\n    if (!n) return 0;\n    const result = parseInt(n);\n\n    return isNaN(result) ? 0 : result;\n  };\n\n  const year = safeParseInt(match.groups.year);\n  const day = safeParseInt(match.groups.day);\n\n  const amPm = match.groups.ampm;\n  let hour = safeParseInt(match.groups.hour);\n\n  if (amPm) hour = amPm === \"PM\" ? hour + 12 : hour;\n\n  const minutes = safeParseInt(match.groups.minutes);\n  const seconds = safeParseInt(match.groups.seconds);\n  const ms = safeParseInt(match.groups.milis);\n\n  const monthName = match.groups.monthname;\n  const monthNameSmall = match.groups.monthnamesmall;\n  let month: number | string = match.groups.month as string;\n  if (monthName) month = MONTH_NAMES.indexOf(monthName);\n  else if (monthNameSmall) {\n    const m = MONTH_NAMES.find((m) =>\n      m.toLowerCase().startsWith(monthNameSmall.toLowerCase())\n    );\n    if (!m) return new Date(date);\n    month = MONTH_NAMES.indexOf(m);\n  } else month = safeParseInt(`${month}`);\n\n  return new Date(year, month - 1, day, hour, minutes, seconds, ms);\n}\n\n/**\n * @summary Binds a date format to a string\n * @param {Date} [date]\n * @param {string} [format]\n * @memberOf module:decorator-validation.Utils.Format\n * @category Utilities\n */\nexport function bindDateToString(date: Date | undefined, format: string) {\n  if (!date) return;\n  const func = () => formatDate(date, format);\n  Object.defineProperty(date, \"toISOString\", {\n    enumerable: false,\n    configurable: false,\n    value: func,\n  });\n  Object.defineProperty(date, \"toString\", {\n    enumerable: false,\n    configurable: false,\n    value: func,\n  });\n  // Object.setPrototypeOf(date, Date.prototype);\n  return date;\n}\n\n/**\n * @summary Helper function to be used instead of instanceOf Date\n * @param date\n * @memberOf module:decorator-validation.Utils.Dates\n * @category Validation\n */\nexport function isValidDate(date: any): boolean {\n  return (\n    date &&\n    Object.prototype.toString.call(date) === \"[object Date]\" &&\n    !Number.isNaN(date)\n  );\n}\n\n/**\n * @summary Util function to pad numbers\n * @param {number} num\n *\n * @return {string}\n *\n * @function twoDigitPad\n * @memberOf module:decorator-validation.Utils.Format\n * @category Format\n */\nexport function twoDigitPad(num: number): string {\n  return num < 10 ? \"0\" + num : num.toString();\n}\n\n/**\n * @summary Date Format Handling\n * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}\n *\n * <pre>\n *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),\n *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.\n *      You can display date, time, AM/PM, etc.\n *\n *      Date and Time Patterns\n *      yy = 2-digit year; yyyy = full year\n *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name\n *      EEEE = full weekday name; EEE = short weekday name\n *      d = digit day; dd = 2-digit day\n *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours\n *      m = minutes; mm = 2-digit minutes; aaa = AM/PM\n *      s = seconds; ss = 2-digit seconds\n *      S = miliseconds\n * </pre>\n *\n * @param {Date} date\n * @param {string} [patternStr] defaults to 'yyyy/MM/dd'\n * @return {string} the formatted date\n *\n * @function formatDate\n * @memberOf module:decorator-validation.Utils.Dates\n * @category Format\n */\nexport function formatDate(date: Date, patternStr: string = \"yyyy/MM/dd\") {\n  const day: number = date.getDate(),\n    month: number = date.getMonth(),\n    year: number = date.getFullYear(),\n    hour: number = date.getHours(),\n    minute: number = date.getMinutes(),\n    second: number = date.getSeconds(),\n    miliseconds: number = date.getMilliseconds(),\n    h: number = hour % 12,\n    hh: string = twoDigitPad(h),\n    HH: string = twoDigitPad(hour),\n    mm: string = twoDigitPad(minute),\n    ss: string = twoDigitPad(second),\n    aaa: string = hour < 12 ? \"AM\" : \"PM\",\n    EEEE: string = DAYS_OF_WEEK_NAMES[date.getDay()],\n    EEE: string = EEEE.substr(0, 3),\n    dd: string = twoDigitPad(day),\n    M: number = month + 1,\n    MM: string = twoDigitPad(M),\n    MMMM: string = MONTH_NAMES[month],\n    MMM: string = MMMM.substr(0, 3),\n    yyyy: string = year + \"\",\n    yy: string = yyyy.substr(2, 2);\n  // checks to see if month name will be used\n  patternStr = patternStr\n    .replace(\"hh\", hh)\n    .replace(\"h\", h.toString())\n    .replace(\"HH\", HH)\n    .replace(\"H\", hour.toString())\n    .replace(\"mm\", mm)\n    .replace(\"m\", minute.toString())\n    .replace(\"ss\", ss)\n    .replace(\"s\", second.toString())\n    .replace(\"S\", miliseconds.toString())\n    .replace(\"dd\", dd)\n    .replace(\"d\", day.toString())\n\n    .replace(\"EEEE\", EEEE)\n    .replace(\"EEE\", EEE)\n    .replace(\"yyyy\", yyyy)\n    .replace(\"yy\", yy)\n    .replace(\"aaa\", aaa);\n  if (patternStr.indexOf(\"MMM\") > -1) {\n    patternStr = patternStr.replace(\"MMMM\", MMMM).replace(\"MMM\", MMM);\n  } else {\n    patternStr = patternStr.replace(\"MM\", MM).replace(\"M\", M.toString());\n  }\n  return patternStr;\n}\n\n/**\n * @summary Parses a date from a specified format\n * @param {string} format\n * @param {string | Date | number} [v]\n * @memberOf module:decorator-validation.Utils.Dates\n * @category Format\n */\nexport function parseDate(format: string, v?: string | Date | number) {\n  let value: Date | undefined = undefined;\n\n  if (!v) return undefined;\n\n  if (v instanceof Date)\n    try {\n      value = dateFromFormat(formatDate(v as Date, format), format);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      throw new Error(\n        sf(\"Could not convert date {0} to format: {1}\", v.toString(), format)\n      );\n    }\n  else if (typeof v === \"string\") {\n    value = dateFromFormat(v, format);\n  } else if (typeof v === \"number\") {\n    const d = new Date(v);\n    value = dateFromFormat(formatDate(d, format), format);\n  } else if (isValidDate(v)) {\n    try {\n      const d = new Date(v);\n      value = dateFromFormat(formatDate(d, format), format);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e) {\n      throw new Error(\n        sf(\"Could not convert date {0} to format: {1}\", v, format)\n      );\n    }\n  } else {\n    throw new Error(`Invalid value provided ${v}`);\n  }\n  return bindDateToString(value, format);\n}\n"]}