@decaf-ts/decorator-validation 1.5.1 → 1.5.2

package/lib/esm/utils/dates.js

@@ -1,243 +0,0 @@
-import "reflect-metadata";
-import { DAYS_OF_WEEK_NAMES, MONTH_NAMES, } from "../validation/Validators/constants";
-import { sf } from "./strings";
-/**
- * @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 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 = MONTH_NAMES.indexOf(monthName);
-    else if (monthNameSmall) {
-        const m = MONTH_NAMES.find((m) => m.toLowerCase().startsWith(monthNameSmall.toLowerCase()));
-        if (!m)
-            return new Date(date);
-        month = 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
- */
-export 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
- */
-export 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
- */
-export 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
- */
-export 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 = DAYS_OF_WEEK_NAMES[date.getDay()], EEE = EEEE.substr(0, 3), dd = twoDigitPad(day), M = month + 1, MM = twoDigitPad(M), MMMM = 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
- */
-export 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(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(sf("Could not convert date {0} to format: {1}", v, format));
-        }
-    }
-    else {
-        throw new Error(`Invalid value provided ${v}`);
-    }
-    return bindDateToString(value, format);
-}

package/lib/esm/utils/decorators.d.ts

@@ -1,2 +0,0 @@
-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/esm/utils/decorators.js

@@ -1,18 +0,0 @@
-import { apply, metadata } from "@decaf-ts/reflection";
-import { ModelKeys } from "./constants";
-export function prop(key = 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);
-    };
-}
-export function propMetadata(key, value) {
-    return apply(prop(), metadata(key, value));
-}

package/lib/esm/utils/hashing.d.ts

@@ -1,52 +0,0 @@
-/**
- * @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/esm/utils/hashing.js

@@ -1,99 +0,0 @@
-import { Serialization } from "./serialization";
-/**
- * @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 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
- */
-export function hashSerialization(obj) {
-    return hashCode(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
- */
-export 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();
-}
-export const DefaultHashingMethod = "default";
-export class Hashing {
-    static { this.current = 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);
-    }
-}

package/lib/esm/utils/index.d.ts

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

package/lib/esm/utils/index.js

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

package/lib/esm/utils/registry.d.ts

@@ -1,68 +0,0 @@
-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/esm/utils/registry.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/serialization.d.ts

@@ -1,79 +0,0 @@
-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/esm/utils/serialization.js

@@ -1,88 +0,0 @@
-import { Model } from "../model/Model";
-import { ModelKeys } from "./constants";
-/**
- * @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 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.getMetadata(model);
-        toSerialize[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[ModelKeys.ANCHOR];
-        if (!className)
-            throw new Error("Could not find class reference in serialized model");
-        const model = 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));
-    }
-}
-export const DefaultSerializationMethod = "json";
-export class Serialization {
-    static { this.current = 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);
-    }
-}