typia 3.3.12

package/lib/metadata/IMetadataTag.d.ts

@@ -0,0 +1,74 @@
+export declare type IMetadataTag = IMetadataTag.IItems | IMetadataTag.IMinItems | IMetadataTag.IMaxItems | IMetadataTag.IFormat | IMetadataTag.IPattern | IMetadataTag.ILength | IMetadataTag.IMinLength | IMetadataTag.IMaxLength | IMetadataTag.IType | IMetadataTag.IRange | IMetadataTag.IMinimum | IMetadataTag.IMaximum | IMetadataTag.IExclusiveMinimum | IMetadataTag.IExclusiveMaximum | IMetadataTag.IMultipleOf | IMetadataTag.IStep;
+export declare namespace IMetadataTag {
+    interface IItems {
+        kind: "items";
+        minimum?: ISign;
+        maximum?: ISign;
+    }
+    interface IMinItems {
+        kind: "minItems";
+        value: number;
+    }
+    interface IMaxItems {
+        kind: "maxItems";
+        value: number;
+    }
+    interface IFormat {
+        kind: "format";
+        value: "uuid" | "email" | "url" | "ipv4" | "ipv6";
+    }
+    interface IPattern {
+        kind: "pattern";
+        value: string;
+    }
+    interface ILength {
+        kind: "length";
+        minimum?: ISign;
+        maximum?: ISign;
+    }
+    interface IMinLength {
+        kind: "minLength";
+        value: number;
+    }
+    interface IMaxLength {
+        kind: "maxLength";
+        value: number;
+    }
+    interface IType {
+        kind: "type";
+        value: "int" | "uint";
+    }
+    interface IRange {
+        kind: "range";
+        minimum?: ISign;
+        maximum?: ISign;
+    }
+    interface IMinimum {
+        kind: "minimum";
+        value: number;
+    }
+    interface IMaximum {
+        kind: "maximum";
+        value: number;
+    }
+    interface IExclusiveMinimum {
+        kind: "exclusiveMinimum";
+        value: number;
+    }
+    interface IExclusiveMaximum {
+        kind: "exclusiveMaximum";
+        value: number;
+    }
+    interface IMultipleOf {
+        kind: "multipleOf";
+        value: number;
+    }
+    interface IStep {
+        kind: "step";
+        value: number;
+    }
+    interface ISign {
+        include: boolean;
+        value: number;
+    }
+}

package/lib/metadata/IMetadataTag.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IMetadataTag.js.map

package/lib/metadata/IMetadataTag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMetadataTag.js","sourceRoot":"","sources":["../../src/metadata/IMetadataTag.ts"],"names":[],"mappings":""}

package/lib/metadata/Metadata.d.ts

@@ -0,0 +1,33 @@
+import { Atomic } from "../typings/Atomic";
+import { IMetadata } from "./IMetadata";
+import { IMetadataObject } from "./IMetadataObject";
+import { MetadataConstant } from "./MetadataConstant";
+import { MetadataObject } from "./MetadataObject";
+export declare class Metadata {
+    readonly any: boolean;
+    readonly required: boolean;
+    readonly nullable: boolean;
+    readonly functional: boolean;
+    readonly resolved: Metadata | null;
+    readonly atomics: Atomic.Literal[];
+    readonly constants: MetadataConstant[];
+    readonly templates: Metadata[][];
+    readonly arrays: Metadata[];
+    readonly tuples: Metadata[][];
+    readonly objects: MetadataObject[];
+    /**
+     * @hidden
+     */
+    private constructor();
+    toJSON(): IMetadata;
+    static from(meta: IMetadata, objects: IMetadataObject[]): Metadata;
+    getName(): string;
+    empty(): boolean;
+    size(): number;
+    bucket(): number;
+    isConstant(): boolean;
+}
+export declare namespace Metadata {
+    function intersects(x: Metadata, y: Metadata, deep: boolean): boolean;
+    function covers(x: Metadata, y: Metadata): boolean;
+}

package/lib/metadata/Metadata.js

@@ -0,0 +1,568 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metadata = void 0;
+var MetadataObject_1 = require("./MetadataObject");
+var MetadataProperty_1 = require("./MetadataProperty");
+var Metadata = (function () {
+    function Metadata(props) {
+        this.name_ = undefined;
+        this.any = props.any;
+        this.required = props.required;
+        this.nullable = props.nullable;
+        this.functional = props.functional;
+        this.resolved = props.resolved;
+        this.atomics = props.atomics;
+        this.constants = props.constants;
+        this.templates = props.templates;
+        this.arrays = props.arrays;
+        this.tuples = props.tuples;
+        this.objects = props.objects;
+    }
+    Metadata.create = function (props) {
+        return new Metadata(props);
+    };
+    Metadata.initialize = function () {
+        return this.create({
+            any: false,
+            nullable: false,
+            required: true,
+            functional: false,
+            resolved: null,
+            constants: [],
+            atomics: [],
+            templates: [],
+            arrays: [],
+            tuples: [],
+            objects: [],
+        });
+    };
+    Metadata.prototype.toJSON = function () {
+        return {
+            any: this.any,
+            required: this.required,
+            nullable: this.nullable,
+            functional: this.functional,
+            atomics: this.atomics.slice(),
+            constants: JSON.parse(JSON.stringify(this.constants)),
+            templates: this.templates.map(function (tpl) {
+                return tpl.map(function (meta) { return meta.toJSON(); });
+            }),
+            resolved: this.resolved ? this.resolved.toJSON() : null,
+            arrays: this.arrays.map(function (meta) { return meta.toJSON(); }),
+            tuples: this.tuples.map(function (meta) {
+                return meta.map(function (meta) { return meta.toJSON(); });
+            }),
+            objects: this.objects.map(function (obj) { return obj.name; }),
+        };
+    };
+    Metadata.from = function (meta, objects) {
+        var e_1, _a, e_2, _b, _c;
+        var dict = new Map();
+        try {
+            for (var objects_1 = __values(objects), objects_1_1 = objects_1.next(); !objects_1_1.done; objects_1_1 = objects_1.next()) {
+                var obj = objects_1_1.value;
+                dict.set(obj.name, MetadataObject_1.MetadataObject._From_without_properties(obj));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (objects_1_1 && !objects_1_1.done && (_a = objects_1.return)) _a.call(objects_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var objects_2 = __values(objects), objects_2_1 = objects_2.next(); !objects_2_1.done; objects_2_1 = objects_2.next()) {
+                var obj = objects_2_1.value;
+                var initialized = dict.get(obj.name);
+                (_c = initialized.properties).push.apply(_c, __spreadArray([], __read(obj.properties.map(function (prop) {
+                    return MetadataProperty_1.MetadataProperty._From(prop, dict);
+                })), false));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (objects_2_1 && !objects_2_1.done && (_b = objects_2.return)) _b.call(objects_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return this._From(meta, dict);
+    };
+    Metadata._From = function (meta, objects) {
+        var _this = this;
+        return this.create({
+            any: meta.any,
+            required: meta.required,
+            nullable: meta.nullable,
+            functional: meta.functional,
+            constants: JSON.parse(JSON.stringify(meta.constants)),
+            atomics: meta.atomics.slice(),
+            templates: meta.templates.map(function (tpl) {
+                return tpl.map(function (meta) { return _this._From(meta, objects); });
+            }),
+            resolved: meta.resolved ? this._From(meta.resolved, objects) : null,
+            arrays: meta.arrays.map(function (meta) { return _this._From(meta, objects); }),
+            tuples: meta.tuples.map(function (tuple) {
+                return tuple.map(function (meta) { return _this._From(meta, objects); });
+            }),
+            objects: meta.objects.map(function (name) {
+                var found = objects.get(name);
+                if (found === undefined)
+                    throw new Error("Error on Metadata.from(): failed to find object \"".concat(name, "\"."));
+                return found;
+            }),
+        });
+    };
+    Metadata.prototype.getName = function () {
+        this.name_ || (this.name_ = getName(this));
+        return this.name_;
+    };
+    Metadata.prototype.empty = function () {
+        return this.bucket() === 0 || this.size() === 0;
+    };
+    Metadata.prototype.size = function () {
+        return ((this.resolved ? 1 : 0) +
+            (this.functional ? 1 : 0) +
+            this.templates.length +
+            this.atomics.length +
+            this.constants
+                .map(function (c) { return c.values.length; })
+                .reduce(function (x, y) { return x + y; }, 0) +
+            this.arrays.length +
+            this.tuples.length +
+            this.objects.length);
+    };
+    Metadata.prototype.bucket = function () {
+        return ((this.resolved ? 1 : 0) +
+            (this.functional ? 1 : 0) +
+            (this.templates.length ? 1 : 0) +
+            (this.atomics.length ? 1 : 0) +
+            (this.constants.length ? 1 : 0) +
+            (this.arrays.length ? 1 : 0) +
+            (this.tuples.length ? 1 : 0) +
+            (this.objects.length ? 1 : 0));
+    };
+    Metadata.prototype.isConstant = function () {
+        return this.bucket() === (this.constants.length ? 1 : 0);
+    };
+    Metadata.prototype.isUnionBucket = function () {
+        var size = this.bucket();
+        var emended = this.constants.length ? size - 1 : size;
+        return emended > 1;
+    };
+    Metadata.prototype.getSoleLiteral = function () {
+        if (this.size() === 1 &&
+            this.constants.length === 1 &&
+            this.constants[0].type === "string" &&
+            this.constants[0].values.length === 1)
+            return this.constants[0].values[0];
+        else
+            return null;
+    };
+    Metadata.prototype.isSoleLiteral = function () {
+        return this.getSoleLiteral() !== null;
+    };
+    return Metadata;
+}());
+exports.Metadata = Metadata;
+(function (Metadata) {
+    function intersects(x, y, deep) {
+        var e_3, _a, e_4, _b, e_5, _c, e_6, _d, e_7, _e, e_8, _f, e_9, _g, e_10, _h;
+        if (x.any || y.any)
+            return true;
+        if (x.required === false && false === y.required)
+            return true;
+        if (x.nullable === true && true === y.nullable)
+            return true;
+        if (deep === true) {
+            try {
+                for (var _j = __values(x.arrays), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var xa = _k.value;
+                    try {
+                        for (var _l = (e_4 = void 0, __values(y.arrays)), _m = _l.next(); !_m.done; _m = _l.next()) {
+                            var ya = _m.value;
+                            if (intersects(xa, ya, deep)) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_m && !_m.done && (_b = _l.return)) _b.call(_l);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_a = _j.return)) _a.call(_j);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var _o = __values(x.objects), _p = _o.next(); !_p.done; _p = _o.next()) {
+                    var xo = _p.value;
+                    try {
+                        for (var _q = (e_6 = void 0, __values(y.objects)), _r = _q.next(); !_r.done; _r = _q.next()) {
+                            var yo = _r.value;
+                            if (MetadataObject_1.MetadataObject.intersects(xo, yo)) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (_r && !_r.done && (_d = _q.return)) _d.call(_q);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_p && !_p.done && (_c = _o.return)) _c.call(_o);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+        else {
+            if (x.arrays.length && y.arrays.length)
+                return true;
+            if (x.objects.length && y.objects.length)
+                return true;
+        }
+        try {
+            for (var _s = __values(x.tuples), _t = _s.next(); !_t.done; _t = _s.next()) {
+                var xt = _t.value;
+                var _loop_1 = function (yt) {
+                    if (xt
+                        .slice(0, Math.min(xt.length, yt.length))
+                        .some(function (xv, i) { return intersects(xv, yt[i], deep); }))
+                        return { value: true };
+                };
+                try {
+                    for (var _u = (e_8 = void 0, __values(y.tuples)), _v = _u.next(); !_v.done; _v = _u.next()) {
+                        var yt = _v.value;
+                        var state_1 = _loop_1(yt);
+                        if (typeof state_1 === "object")
+                            return state_1.value;
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (_v && !_v.done && (_f = _u.return)) _f.call(_u);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_t && !_t.done && (_e = _s.return)) _e.call(_s);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        try {
+            for (var _w = __values(x.atomics), _x = _w.next(); !_x.done; _x = _w.next()) {
+                var atomic = _x.value;
+                if (y.atomics.includes(atomic))
+                    return true;
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_x && !_x.done && (_g = _w.return)) _g.call(_w);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        var _loop_2 = function (constant) {
+            var opposite = y.constants.find(function (elem) { return elem.type === constant.type; });
+            if (opposite === undefined)
+                return "continue";
+            var values = new Set(__spreadArray(__spreadArray([], __read(constant.values), false), __read(opposite.values), false));
+            if (values.size !== constant.values.length + opposite.values.length)
+                return { value: true };
+        };
+        try {
+            for (var _y = __values(x.constants), _z = _y.next(); !_z.done; _z = _y.next()) {
+                var constant = _z.value;
+                var state_2 = _loop_2(constant);
+                if (typeof state_2 === "object")
+                    return state_2.value;
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_z && !_z.done && (_h = _y.return)) _h.call(_y);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        if (x.functional === true && y.functional === true)
+            return true;
+        return false;
+    }
+    Metadata.intersects = intersects;
+    function covers(x, y) {
+        var e_11, _a, e_12, _b, e_13, _c, e_14, _d;
+        if (x.any)
+            return true;
+        else if (y.any)
+            return false;
+        var _loop_3 = function (ya) {
+            if (x.arrays.some(function (xa) { return covers(xa, ya) === true; }) === false)
+                return { value: false };
+        };
+        try {
+            for (var _e = __values(y.arrays), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var ya = _f.value;
+                var state_3 = _loop_3(ya);
+                if (typeof state_3 === "object")
+                    return state_3.value;
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        var _loop_4 = function (yo) {
+            if (x.objects.some(function (xo) { return MetadataObject_1.MetadataObject.covers(xo, yo); }) === false)
+                return { value: false };
+        };
+        try {
+            for (var _g = __values(y.objects), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var yo = _h.value;
+                var state_4 = _loop_4(yo);
+                if (typeof state_4 === "object")
+                    return state_4.value;
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        var _loop_5 = function (yt) {
+            if (x.tuples.some(function (xt) {
+                return xt.length >= yt.length &&
+                    xt
+                        .slice(yt.length)
+                        .every(function (xv, i) { return covers(xv, yt[i]); });
+            }) === false)
+                return { value: false };
+        };
+        try {
+            for (var _j = __values(y.tuples), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var yt = _k.value;
+                var state_5 = _loop_5(yt);
+                if (typeof state_5 === "object")
+                    return state_5.value;
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        if (y.atomics.some(function (atomic) { return x.atomics.includes(atomic) === false; }))
+            return false;
+        var _loop_6 = function (yc) {
+            var xc = x.constants.find(function (elem) { return elem.type === yc.type; });
+            if (xc === undefined)
+                return { value: false };
+            else if (yc.values.some(function (yv) { return xc.values.includes(yv) === false; }))
+                return { value: false };
+        };
+        try {
+            for (var _l = __values(y.constants), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var yc = _m.value;
+                var state_6 = _loop_6(yc);
+                if (typeof state_6 === "object")
+                    return state_6.value;
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        if (x.functional === false && y.functional)
+            return false;
+        return true;
+    }
+    Metadata.covers = covers;
+})(Metadata = exports.Metadata || (exports.Metadata = {}));
+exports.Metadata = Metadata;
+function getName(metadata) {
+    var e_15, _a, e_16, _b, e_17, _c, e_18, _d, e_19, _e, e_20, _f, e_21, _g;
+    if (metadata.any === true)
+        return "any";
+    var elements = [];
+    if (metadata.nullable === true)
+        elements.push("null");
+    if (metadata.required === false)
+        elements.push("undefined");
+    try {
+        for (var _h = __values(metadata.atomics), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var type = _j.value;
+            elements.push(type);
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    try {
+        for (var _k = __values(metadata.constants), _l = _k.next(); !_l.done; _l = _k.next()) {
+            var constant = _l.value;
+            try {
+                for (var _m = (e_17 = void 0, __values(constant.values)), _o = _m.next(); !_o.done; _o = _m.next()) {
+                    var value = _o.value;
+                    elements.push(JSON.stringify(value));
+                }
+            }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
+            finally {
+                try {
+                    if (_o && !_o.done && (_c = _m.return)) _c.call(_m);
+                }
+                finally { if (e_17) throw e_17.error; }
+            }
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    try {
+        for (var _p = __values(metadata.templates), _q = _p.next(); !_q.done; _q = _p.next()) {
+            var template = _q.value;
+            elements.push("`" +
+                template
+                    .map(function (child) {
+                    return child.isConstant() && child.size() === 1
+                        ? child.constants[0].values[0]
+                        : "${".concat(child.getName(), "}");
+                })
+                    .join("")
+                    .split("`")
+                    .join("\\`") +
+                "`");
+        }
+    }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+    finally {
+        try {
+            if (_q && !_q.done && (_d = _p.return)) _d.call(_p);
+        }
+        finally { if (e_18) throw e_18.error; }
+    }
+    try {
+        for (var _r = __values(metadata.tuples), _s = _r.next(); !_s.done; _s = _r.next()) {
+            var tuple = _s.value;
+            elements.push("[".concat(tuple.map(function (elem) { return elem.getName(); }).join(", "), "]"));
+        }
+    }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    finally {
+        try {
+            if (_s && !_s.done && (_e = _r.return)) _e.call(_r);
+        }
+        finally { if (e_19) throw e_19.error; }
+    }
+    try {
+        for (var _t = __values(metadata.arrays), _u = _t.next(); !_u.done; _u = _t.next()) {
+            var array = _u.value;
+            elements.push("Array<".concat(array.getName(), ">"));
+        }
+    }
+    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+    finally {
+        try {
+            if (_u && !_u.done && (_f = _t.return)) _f.call(_t);
+        }
+        finally { if (e_20) throw e_20.error; }
+    }
+    try {
+        for (var _v = __values(metadata.objects), _w = _v.next(); !_w.done; _w = _v.next()) {
+            var object = _w.value;
+            elements.push("Resolve<".concat(object.name, ">"));
+        }
+    }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    finally {
+        try {
+            if (_w && !_w.done && (_g = _v.return)) _g.call(_v);
+        }
+        finally { if (e_21) throw e_21.error; }
+    }
+    if (metadata.resolved !== null)
+        elements.push(metadata.resolved.getName());
+    if (elements.length === 0)
+        return "unknown";
+    else if (elements.length === 1)
+        return elements[0];
+    elements.sort();
+    return "(".concat(elements.join(" | "), ")");
+}
+//# sourceMappingURL=Metadata.js.map