@decaf-ts/decorator-validation 1.5.2 → 1.5.5

package/lib/utils/dates.d.ts

@@ -0,0 +1,76 @@
+import "reflect-metadata";
+/**
+ * @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
+ */
+export declare function dateFromFormat(date: string, format: string): Date;
+/**
+ * @summary Binds a date format to a string
+ * @param {Date} [date]
+ * @param {string} [format]
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Utilities
+ */
+export declare function bindDateToString(date: Date | undefined, format: string): Date | undefined;
+/**
+ * @summary Helper function to be used instead of instanceOf Date
+ * @param date
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Validation
+ */
+export declare function isValidDate(date: any): boolean;
+/**
+ * @summary Util function to pad numbers
+ * @param {number} num
+ *
+ * @return {string}
+ *
+ * @function twoDigitPad
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+export declare function twoDigitPad(num: number): string;
+/**
+ * @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
+ */
+export declare function formatDate(date: Date, patternStr?: string): string;
+/**
+ * @summary Parses a date from a specified format
+ * @param {string} format
+ * @param {string | Date | number} [v]
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+export declare function parseDate(format: string, v?: string | Date | number): Date | undefined;

package/lib/utils/decorators.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prop = prop;
+exports.propMetadata = propMetadata;
+const reflection_1 = require("@decaf-ts/reflection");
+const constants_1 = require("./constants.cjs");
+function prop(key = constants_1.ModelKeys.ATTRIBUTE) {
+    return (model, propertyKey) => {
+        let props;
+        if (Object.prototype.hasOwnProperty.call(model, key)) {
+            props = model[key];
+        }
+        else {
+            props = model[key] = [];
+        }
+        if (!props.includes(propertyKey))
+            props.push(propertyKey);
+    };
+}
+function propMetadata(key, value) {
+    return (0, reflection_1.apply)(prop(), (0, reflection_1.metadata)(key, value));
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9kZWNvcmF0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0Esb0JBV0M7QUFFRCxvQ0FFQztBQWxCRCxxREFBdUQ7QUFDdkQsMkNBQXdDO0FBRXhDLFNBQWdCLElBQUksQ0FBQyxNQUFjLHFCQUFTLENBQUMsU0FBUztJQUNwRCxPQUFPLENBQUMsS0FBYSxFQUFFLFdBQWlCLEVBQVEsRUFBRTtRQUNoRCxJQUFJLEtBQWUsQ0FBQztRQUNwQixJQUFJLE1BQU0sQ0FBQyxTQUFTLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNyRCxLQUFLLEdBQUksS0FBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzlCLENBQUM7YUFBTSxDQUFDO1lBQ04sS0FBSyxHQUFJLEtBQWEsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDbkMsQ0FBQztRQUNELElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLFdBQXFCLENBQUM7WUFDeEMsS0FBSyxDQUFDLElBQUksQ0FBQyxXQUFxQixDQUFDLENBQUM7SUFDdEMsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQUVELFNBQWdCLFlBQVksQ0FBSSxHQUFXLEVBQUUsS0FBUTtJQUNuRCxPQUFPLElBQUEsa0JBQUssRUFBQyxJQUFJLEVBQUUsRUFBRSxJQUFBLHFCQUFRLEVBQUksR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7QUFDaEQsQ0FBQyIsImZpbGUiOiJ1dGlscy9kZWNvcmF0b3JzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXBwbHksIG1ldGFkYXRhIH0gZnJvbSBcIkBkZWNhZi10cy9yZWZsZWN0aW9uXCI7XG5pbXBvcnQgeyBNb2RlbEtleXMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHByb3Aoa2V5OiBzdHJpbmcgPSBNb2RlbEtleXMuQVRUUklCVVRFKSB7XG4gIHJldHVybiAobW9kZWw6IG9iamVjdCwgcHJvcGVydHlLZXk/OiBhbnkpOiB2b2lkID0+IHtcbiAgICBsZXQgcHJvcHM6IHN0cmluZ1tdO1xuICAgIGlmIChPYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LmNhbGwobW9kZWwsIGtleSkpIHtcbiAgICAgIHByb3BzID0gKG1vZGVsIGFzIGFueSlba2V5XTtcbiAgICB9IGVsc2Uge1xuICAgICAgcHJvcHMgPSAobW9kZWwgYXMgYW55KVtrZXldID0gW107XG4gICAgfVxuICAgIGlmICghcHJvcHMuaW5jbHVkZXMocHJvcGVydHlLZXkgYXMgc3RyaW5nKSlcbiAgICAgIHByb3BzLnB1c2gocHJvcGVydHlLZXkgYXMgc3RyaW5nKTtcbiAgfTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHByb3BNZXRhZGF0YTxWPihrZXk6IHN0cmluZywgdmFsdWU6IFYpIHtcbiAgcmV0dXJuIGFwcGx5KHByb3AoKSwgbWV0YWRhdGE8Vj4oa2V5LCB2YWx1ZSkpO1xufVxuIl19

package/lib/utils/decorators.d.ts

@@ -0,0 +1,2 @@
+export declare function prop(key?: string): (model: object, propertyKey?: any) => void;
+export declare function propMetadata<V>(key: string, value: V): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/utils/hashing.cjs

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hashing = exports.DefaultHashingMethod = void 0;
+exports.hashCode = hashCode;
+exports.hashSerialization = hashSerialization;
+exports.hashObj = hashObj;
+const serialization_1 = require("./serialization.cjs");
+/**
+ * @summary Mimics Java's String's Hash implementation
+ *
+ * @param {string | number | symbol | Date} obj
+ * @return {number} hash value of obj
+ *
+ * @function hashCode
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+function hashCode(obj) {
+    obj = String(obj);
+    let hash = 0;
+    for (let i = 0; i < obj.length; i++) {
+        const character = obj.charCodeAt(i);
+        hash = (hash << 5) - hash + character;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString();
+}
+/**
+ * @summary Hashes an object serializing it and then hashing the string
+ * @description The Serialization algorithm used by default (JSON.stringify)
+ * is not deterministic and should not be used for hashing
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashSerialization
+ * @memberOf module:decorator-validation.Utils.Hashing
+ *
+ * @category Hashing
+ */
+function hashSerialization(obj) {
+    return hashCode(serialization_1.Serialization.serialize(obj));
+}
+/**
+ * @summary Hashes an object by combining the hash of all its properties
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashObj
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+function hashObj(obj) {
+    const hashReducer = function (h, el) {
+        const elHash = hashFunction(el);
+        if (typeof elHash === "string")
+            return hashFunction((h || "") + hashFunction(el));
+        h = h || 0;
+        h = (h << 5) - h + elHash;
+        return h & h;
+    };
+    const func = hashCode;
+    const hashFunction = function (value) {
+        if (typeof value === "undefined")
+            return "";
+        if (["string", "number", "symbol"].indexOf(typeof value) !== -1)
+            return func(value.toString());
+        if (value instanceof Date)
+            return func(value.getTime());
+        if (Array.isArray(value))
+            return value.reduce(hashReducer, undefined);
+        return Object.values(value).reduce(hashReducer, undefined);
+    };
+    const result = Object.values(obj).reduce(hashReducer, 0);
+    return (typeof result === "number" ? Math.abs(result) : result).toString();
+}
+exports.DefaultHashingMethod = "default";
+class Hashing {
+    static { this.current = exports.DefaultHashingMethod; }
+    static { this.cache = {
+        default: hashObj,
+    }; }
+    constructor() { }
+    static get(key) {
+        if (key in this.cache)
+            return this.cache[key];
+        throw new Error(`No hashing method registered under ${key}`);
+    }
+    static register(key, func, setDefault = false) {
+        if (key in this.cache)
+            throw new Error(`Hashing method ${key} already registered`);
+        this.cache[key] = func;
+        if (setDefault)
+            this.current = key;
+    }
+    static hash(obj, method, ...args) {
+        if (!method)
+            return this.get(this.current)(obj, ...args);
+        return this.get(method)(obj, ...args);
+    }
+    static setDefault(method) {
+        this.current = this.get(method);
+    }
+}
+exports.Hashing = Hashing;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/hashing.ts"],"names":[],"mappings":"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","file":"utils/hashing.js","sourcesContent":["import { Serialization } from \"./serialization\";\n\n/**\n * @summary Mimics Java's String's Hash implementation\n *\n * @param {string | number | symbol | Date} obj\n * @return {number} hash value of obj\n *\n * @function hashCode\n * @memberOf module:decorator-validation.Utils.Hashing\n * @category Hashing\n */\nexport function hashCode(obj: string | number | symbol | Date): string {\n  obj = String(obj);\n  let hash = 0;\n  for (let i = 0; i < obj.length; i++) {\n    const character = obj.charCodeAt(i);\n    hash = (hash << 5) - hash + character;\n    hash = hash & hash; // Convert to 32bit integer\n  }\n  return hash.toString();\n}\n\n/**\n * @summary Defines teh type for a Hashing function\n * @memberOf module:decorator-validation.Utils.Hashing\n * @category Hashing\n */\nexport type HashingFunction = (value: any, ...args: any[]) => string;\n\n/**\n * @summary Hashes an object serializing it and then hashing the string\n * @description The Serialization algorithm used by default (JSON.stringify)\n * is not deterministic and should not be used for hashing\n *\n * @param {Record<string, any>} obj\n * @return {string} the resulting hash\n *\n * @function hashSerialization\n * @memberOf module:decorator-validation.Utils.Hashing\n *\n * @category Hashing\n */\nexport function hashSerialization(obj: Record<string, any> | any[]) {\n  return hashCode(Serialization.serialize(obj));\n}\n\n/**\n * @summary Hashes an object by combining the hash of all its properties\n *\n * @param {Record<string, any>} obj\n * @return {string} the resulting hash\n *\n * @function hashObj\n * @memberOf module:decorator-validation.Utils.Hashing\n * @category Hashing\n */\nexport function hashObj(obj: Record<string, any> | any[]): string {\n  const hashReducer = function (h: number | string, el: any): string | number {\n    const elHash = hashFunction(el);\n\n    if (typeof elHash === \"string\")\n      return hashFunction(((h as string) || \"\") + hashFunction(el));\n\n    h = h || 0;\n    h = ((h as number) << 5) - (h as number) + elHash;\n    return h & h;\n  };\n\n  const func: HashingFunction = hashCode;\n\n  const hashFunction = function (value: any): string | number {\n    if (typeof value === \"undefined\") return \"\";\n    if ([\"string\", \"number\", \"symbol\"].indexOf(typeof value) !== -1)\n      return func(value.toString());\n    if (value instanceof Date) return func(value.getTime());\n    if (Array.isArray(value)) return value.reduce(hashReducer, undefined);\n    return (Object.values(value) as (string | number)[]).reduce(\n      hashReducer,\n      undefined as unknown as string | number,\n    );\n  };\n\n  const result = Object.values(obj).reduce(hashReducer, 0);\n\n  return (typeof result === \"number\" ? Math.abs(result) : result).toString();\n}\n\nexport const DefaultHashingMethod = \"default\";\n\nexport class Hashing {\n  private static current: string = DefaultHashingMethod;\n\n  private static cache: Record<string, HashingFunction> = {\n    default: hashObj,\n  };\n\n  private constructor() {}\n\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No hashing method registered under ${key}`);\n  }\n\n  static register(\n    key: string,\n    func: HashingFunction,\n    setDefault = false,\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Hashing method ${key} already registered`);\n    this.cache[key] = func;\n    if (setDefault) this.current = key;\n  }\n\n  static hash(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current)(obj, ...args);\n    return this.get(method)(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n"]}

package/lib/utils/hashing.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @summary Mimics Java's String's Hash implementation
+ *
+ * @param {string | number | symbol | Date} obj
+ * @return {number} hash value of obj
+ *
+ * @function hashCode
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export declare function hashCode(obj: string | number | symbol | Date): string;
+/**
+ * @summary Defines teh type for a Hashing function
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export type HashingFunction = (value: any, ...args: any[]) => string;
+/**
+ * @summary Hashes an object serializing it and then hashing the string
+ * @description The Serialization algorithm used by default (JSON.stringify)
+ * is not deterministic and should not be used for hashing
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashSerialization
+ * @memberOf module:decorator-validation.Utils.Hashing
+ *
+ * @category Hashing
+ */
+export declare function hashSerialization(obj: Record<string, any> | any[]): string;
+/**
+ * @summary Hashes an object by combining the hash of all its properties
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashObj
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export declare function hashObj(obj: Record<string, any> | any[]): string;
+export declare const DefaultHashingMethod = "default";
+export declare class Hashing {
+    private static current;
+    private static cache;
+    private constructor();
+    private static get;
+    static register(key: string, func: HashingFunction, setDefault?: boolean): void;
+    static hash(obj: any, method?: string, ...args: any[]): any;
+    static setDefault(method: string): void;
+}

package/lib/utils/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./dates.cjs"), exports);
+__exportStar(require("./decorators.cjs"), exports);
+__exportStar(require("./hashing.cjs"), exports);
+__exportStar(require("./registry.cjs"), exports);
+__exportStar(require("./serialization.cjs"), exports);
+__exportStar(require("./strings.cjs"), exports);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsOENBQTRCO0FBQzVCLDBDQUF3QjtBQUN4QiwrQ0FBNkI7QUFDN0IsNENBQTBCO0FBQzFCLDZDQUEyQjtBQUMzQixrREFBZ0M7QUFDaEMsNENBQTBCIiwiZmlsZSI6InV0aWxzL2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kYXRlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaGFzaGluZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVnaXN0cnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NlcmlhbGl6YXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0cmluZ3NcIjtcbiJdfQ==

package/lib/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./constants";
+export * from "./dates";
+export * from "./decorators";
+export * from "./hashing";
+export * from "./registry";
+export * from "./serialization";
+export * from "./strings";

package/lib/utils/registry.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/utils/registry.d.ts

@@ -0,0 +1,68 @@
+import { Constructor } from "../model/types";
+/**
+ * @summary Basic interface for Registries
+ *
+ * @interface IRegistry
+ *
+ * @category Utilities
+ */
+export interface IRegistry<T> {
+    /**
+     * @summary Registers an Object
+     *
+     * @param {T} obj
+     * @param {any[]} args
+     *
+     * @method
+     */
+    register(obj: T | any, ...args: any[]): void;
+    /**
+     * @summary Retrieves an Object if it can find it
+     *
+     * @param {any} key
+     * @param {any[]} args
+     * @return {T | undefined}
+     *
+     * @method
+     */
+    get(key: any, ...args: any[]): T | undefined;
+}
+/**
+ * @summary Basic Builder Registry Interface
+ *
+ * @typedef T
+ * @interface BuilderRegistry<T>
+ *
+ * @category Construction
+ */
+export interface BuilderRegistry<T> extends IRegistry<Constructor<T>> {
+    /**
+     * @summary Retrieves an Builder Object by name if it can
+     *
+     * @param {string} name
+     * @param {any[]} args
+     *
+     * @method
+     */
+    get(name: string, ...args: any[]): Constructor<T> | undefined;
+    /**
+     * @summary Registers a constructor by name
+     *
+     * @param {Constructor<T>} [constructor]
+     * @param {name} name
+     * @param {any[]} args
+     *
+     * @method
+     */
+    register(constructor: Constructor<T>, name?: string, ...args: any[]): void;
+    /**
+     * @summary Builds an Object by name
+     *
+     * @param {{}} obj
+     * @param {any[]} args
+     * @return T
+     *
+     * @method
+     */
+    build(obj: Record<string, any> | T, ...args: any[]): T;
+}

package/lib/utils/serialization.cjs

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serialization = exports.DefaultSerializationMethod = exports.JSONSerializer = void 0;
+const Model_1 = require("../model/Model.cjs");
+const constants_1 = require("./constants.cjs");
+/**
+ * @summary Concrete implementation of a {@link Serializer} in JSON format
+ * @description JS's native JSON.stringify (used here) is not deterministic
+ * and therefore should not be used for hashing purposes
+ *
+ * To keep dependencies low, we will not implement this, but we recommend
+ * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
+ *
+ * @class JSONSerializer
+ * @implements Serializer
+ *
+ * @category Serialization
+ */
+class JSONSerializer {
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {T} model
+     * @protected
+     */
+    preSerialize(model) {
+        // TODO: nested preserialization (so increase performance when deserializing)
+        const toSerialize = Object.assign({}, model);
+        const metadata = Model_1.Model.getMetadata(model);
+        toSerialize[constants_1.ModelKeys.ANCHOR] = metadata || model.constructor.name;
+        return toSerialize;
+    }
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str) {
+        const deserialization = JSON.parse(str);
+        const className = deserialization[constants_1.ModelKeys.ANCHOR];
+        if (!className)
+            throw new Error("Could not find class reference in serialized model");
+        const model = Model_1.Model.build(deserialization, className);
+        return model;
+    }
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model) {
+        return JSON.stringify(this.preSerialize(model));
+    }
+}
+exports.JSONSerializer = JSONSerializer;
+exports.DefaultSerializationMethod = "json";
+class Serialization {
+    static { this.current = exports.DefaultSerializationMethod; }
+    static { this.cache = {
+        json: new JSONSerializer(),
+    }; }
+    constructor() { }
+    static get(key) {
+        if (key in this.cache)
+            return this.cache[key];
+        throw new Error(`No serialization method registered under ${key}`);
+    }
+    static register(key, func, setDefault = false) {
+        if (key in this.cache)
+            throw new Error(`Serialization method ${key} already registered`);
+        this.cache[key] = new func();
+        if (setDefault)
+            this.current = key;
+    }
+    static serialize(obj, method, ...args) {
+        if (!method)
+            return this.get(this.current).serialize(obj, ...args);
+        return this.get(method).serialize(obj, ...args);
+    }
+    static deserialize(obj, method, ...args) {
+        if (!method)
+            return this.get(this.current).deserialize(obj, ...args);
+        return this.get(method).deserialize(obj, ...args);
+    }
+    static setDefault(method) {
+        this.current = this.get(method);
+    }
+}
+exports.Serialization = Serialization;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils/serialization.ts"],"names":[],"mappings":";;;AAAA,0CAAuC;AACvC,2CAAwC;AAiCxC;;;;;;;;;;;;GAYG;AACH,MAAa,cAAc;IACzB;;;;;;;OAOG;IACO,YAAY,CAAC,KAAQ;QAC7B,6EAA6E;QAC7E,MAAM,WAAW,GAAwB,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAClE,MAAM,QAAQ,GAAG,aAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC1C,WAAW,CAAC,qBAAS,CAAC,MAAM,CAAC,GAAG,QAAQ,IAAI,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;QACnE,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,GAAW;QACrB,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxC,MAAM,SAAS,GAAG,eAAe,CAAC,qBAAS,CAAC,MAAM,CAAC,CAAC;QACpD,IAAI,CAAC,SAAS;YACZ,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,MAAM,KAAK,GAAM,aAAK,CAAC,KAAK,CAAC,eAAe,EAAE,SAAS,CAAiB,CAAC;QACzE,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,KAAQ;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IAClD,CAAC;CACF;AAzCD,wCAyCC;AAEY,QAAA,0BAA0B,GAAG,MAAM,CAAC;AAEjD,MAAa,aAAa;aACT,YAAO,GAAW,kCAA0B,CAAC;aAE7C,UAAK,GAAoC;QACtD,IAAI,EAAE,IAAI,cAAc,EAAE;KAC3B,CAAC;IAEF,gBAAuB,CAAC;IAEhB,MAAM,CAAC,GAAG,CAAC,GAAW;QAC5B,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,4CAA4C,GAAG,EAAE,CAAC,CAAC;IACrE,CAAC;IAED,MAAM,CAAC,QAAQ,CACb,GAAW,EACX,IAAkC,EAClC,UAAU,GAAG,KAAK;QAElB,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;YACnB,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,qBAAqB,CAAC,CAAC;QACpE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC;QAC7B,IAAI,UAAU;YAAE,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;IACrC,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,GAAQ,EAAE,MAAe,EAAE,GAAG,IAAW;QACxD,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;QACnE,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,MAAM,CAAC,WAAW,CAAC,GAAW,EAAE,MAAe,EAAE,GAAG,IAAW;QAC7D,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;QACrE,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,MAAc;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;;AArCH,sCAsCC","file":"utils/serialization.js","sourcesContent":["import { Model } from \"../model/Model\";\nimport { ModelKeys } from \"./constants\";\nimport { Constructor } from \"../model/types\";\n\n/**\n * @summary Helper in serialization\n *\n * @interface Serializer\n * @category Serialization\n */\nexport interface Serializer<T extends Model> {\n  /**\n   * @summary Serializes a model\n   * @param {T} model\n   *\n   * @param args\n   * @method\n   *\n   * @throws {Error}\n   */\n  serialize(model: T, ...args: any[]): string;\n\n  /**\n   * @summary Rebuilds a model from serialization\n   * @param {string} str\n   *\n   * @param args\n   * @method\n   *\n   * @throws {Error}\n   */\n  deserialize(str: string, ...args: any[]): T;\n}\n\n/**\n * @summary Concrete implementation of a {@link Serializer} in JSON format\n * @description JS's native JSON.stringify (used here) is not deterministic\n * and therefore should not be used for hashing purposes\n *\n * To keep dependencies low, we will not implement this, but we recommend\n * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries\n *\n * @class JSONSerializer\n * @implements Serializer\n *\n * @category Serialization\n */\nexport class JSONSerializer<T extends Model> implements Serializer<T> {\n  /**\n   * @summary prepares the model for serialization\n   * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property\n   * so the object can be recognized upon deserialization\n   *\n   * @param {T} model\n   * @protected\n   */\n  protected preSerialize(model: T) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    const metadata = Model.getMetadata(model);\n    toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n    return toSerialize;\n  }\n\n  /**\n   * @summary Rebuilds a model from a serialization\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or to build the model\n   */\n  deserialize(str: string): T {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: T = Model.build(deserialization, className) as unknown as T;\n    return model;\n  }\n\n  /**\n   * @summary Serializes a model\n   * @param {T} model\n   *\n   * @throws {Error} if fails to serialize\n   */\n  serialize(model: T): string {\n    return JSON.stringify(this.preSerialize(model));\n  }\n}\n\nexport const DefaultSerializationMethod = \"json\";\n\nexport class Serialization {\n  private static current: string = DefaultSerializationMethod;\n\n  private static cache: Record<string, Serializer<any>> = {\n    json: new JSONSerializer(),\n  };\n\n  private constructor() {}\n\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No serialization method registered under ${key}`);\n  }\n\n  static register(\n    key: string,\n    func: Constructor<Serializer<any>>,\n    setDefault = false,\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Serialization method ${key} already registered`);\n    this.cache[key] = new func();\n    if (setDefault) this.current = key;\n  }\n\n  static serialize(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current).serialize(obj, ...args);\n    return this.get(method).serialize(obj, ...args);\n  }\n\n  static deserialize(obj: string, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current).deserialize(obj, ...args);\n    return this.get(method).deserialize(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n"]}

package/lib/utils/serialization.d.ts

@@ -0,0 +1,79 @@
+import { Model } from "../model/Model";
+import { Constructor } from "../model/types";
+/**
+ * @summary Helper in serialization
+ *
+ * @interface Serializer
+ * @category Serialization
+ */
+export interface Serializer<T extends Model> {
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @param args
+     * @method
+     *
+     * @throws {Error}
+     */
+    serialize(model: T, ...args: any[]): string;
+    /**
+     * @summary Rebuilds a model from serialization
+     * @param {string} str
+     *
+     * @param args
+     * @method
+     *
+     * @throws {Error}
+     */
+    deserialize(str: string, ...args: any[]): T;
+}
+/**
+ * @summary Concrete implementation of a {@link Serializer} in JSON format
+ * @description JS's native JSON.stringify (used here) is not deterministic
+ * and therefore should not be used for hashing purposes
+ *
+ * To keep dependencies low, we will not implement this, but we recommend
+ * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
+ *
+ * @class JSONSerializer
+ * @implements Serializer
+ *
+ * @category Serialization
+ */
+export declare class JSONSerializer<T extends Model> implements Serializer<T> {
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {T} model
+     * @protected
+     */
+    protected preSerialize(model: T): Record<string, any>;
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str: string): T;
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model: T): string;
+}
+export declare const DefaultSerializationMethod = "json";
+export declare class Serialization {
+    private static current;
+    private static cache;
+    private constructor();
+    private static get;
+    static register(key: string, func: Constructor<Serializer<any>>, setDefault?: boolean): void;
+    static serialize(obj: any, method?: string, ...args: any[]): any;
+    static deserialize(obj: string, method?: string, ...args: any[]): any;
+    static setDefault(method: string): void;
+}

package/lib/utils/strings.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sf = void 0;
+exports.stringFormat = stringFormat;
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function stringFormat
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+function stringFormat(string, ...args) {
+    return string.replace(/{(\d+)}/g, function (match, number) {
+        return typeof args[number] !== "undefined"
+            ? args[number].toString()
+            : "undefined";
+    });
+}
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ * @description alias for {@link stringFormat}
+ *
+ * @param {string} string
+ * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function sf
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+exports.sf = stringFormat;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/utils/strings.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function stringFormat
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+export declare function stringFormat(string: string, ...args: (string | number)[]): string;
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ * @description alias for {@link stringFormat}
+ *
+ * @param {string} string
+ * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function sf
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+export declare const sf: typeof stringFormat;