typia 5.0.5 → 5.1.0-dev.20230922

package/src/schemas/metadata/MetadataObject.ts

@@ -1,139 +1,139 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataObject } from "./IMetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
-
-export class MetadataObject {
-    public readonly name: string;
-    public readonly properties: Array<MetadataProperty>;
-    public readonly description: string | undefined;
-    public readonly jsDocTags: IJsDocTagInfo[];
-
-    public readonly index: number;
-    public validated: boolean;
-    public recursive: boolean;
-    public nullables: boolean[] = [];
-
-    /**
-     * @internal
-     */
-    public tagged_: boolean = false;
-
-    /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-    /**
-     * @hidden
-     */
-    private constructor(
-        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
-    ) {
-        this.name = props.name;
-        this.properties = props.properties;
-        this.description = props.description;
-        this.jsDocTags = props.jsDocTags;
-
-        this.index = props.index;
-        this.validated = props.validated;
-        this.recursive = props.recursive;
-        this.nullables = [];
-
-        this.tagged_ = false;
-    }
-
-    /**
-     * @internal
-     */
-    public static create(
-        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
-    ) {
-        return new MetadataObject(props);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_properties(
-        obj: IMetadataObject,
-    ): MetadataObject {
-        return this.create({
-            name: obj.name,
-            properties: [],
-            description: obj.description,
-            jsDocTags: obj.jsDocTags,
-
-            index: obj.index,
-            validated: obj.validated,
-            recursive: obj.recursive,
-            nullables: obj.nullables.slice(),
-        });
-    }
-
-    /**
-     * @internal
-     */
-    public _Messagable(): boolean {
-        return (
-            this.properties.length >= 1 &&
-            this.properties.every((p) => p.key.isSoleLiteral())
-        );
-    }
-
-    /**
-     * @internal
-     */
-    public _Is_simple(level: number = 0): boolean {
-        return (
-            this.recursive === false &&
-            this.properties.length < 10 &&
-            this.properties.every(
-                (property) =>
-                    property.key.isSoleLiteral() &&
-                    property.value.size() === 1 &&
-                    property.value.isRequired() === true &&
-                    property.value.nullable === false &&
-                    (property.value.atomics.length === 1 ||
-                        (level < 1 &&
-                            property.value.objects.length === 1 &&
-                            property.value.objects[0]!._Is_simple(level + 1))),
-            )
-        );
-    }
-
-    public toJSON(): IMetadataObject {
-        return {
-            name: this.name,
-            properties: this.properties.map((property) => property.toJSON()),
-            description: this.description,
-            jsDocTags: this.jsDocTags,
-
-            index: this.index,
-            validated: this.validated,
-            recursive: this.recursive,
-            nullables: this.nullables.slice(),
-        };
-    }
-}
-
-/**
- * @internal
- */
-export namespace MetadataObject {
-    export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
-        x.properties.some(
-            (prop) =>
-                y.properties.find(
-                    (oppo) => prop.key.getName() === oppo.key.getName(),
-                ) !== undefined,
-        );
-
-    export const covers = (x: MetadataObject, y: MetadataObject): boolean =>
-        x.properties.length >= y.properties.length &&
-        x.properties.every(
-            (prop) =>
-                y.properties.find(
-                    (oppo) => prop.key.getName() === oppo.key.getName(),
-                ) !== undefined,
-        );
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataObject } from "./IMetadataObject";
+import { MetadataProperty } from "./MetadataProperty";
+
+export class MetadataObject {
+    public readonly name: string;
+    public readonly properties: Array<MetadataProperty>;
+    public readonly description: string | undefined;
+    public readonly jsDocTags: IJsDocTagInfo[];
+
+    public readonly index: number;
+    public validated: boolean;
+    public recursive: boolean;
+    public nullables: boolean[] = [];
+
+    /**
+     * @internal
+     */
+    public tagged_: boolean = false;
+
+    /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    private constructor(
+        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
+    ) {
+        this.name = props.name;
+        this.properties = props.properties;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+
+        this.index = props.index;
+        this.validated = props.validated;
+        this.recursive = props.recursive;
+        this.nullables = [];
+
+        this.tagged_ = false;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: Omit<ClassProperties<MetadataObject>, "tagged_">,
+    ) {
+        return new MetadataObject(props);
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_properties(
+        obj: IMetadataObject,
+    ): MetadataObject {
+        return this.create({
+            name: obj.name,
+            properties: [],
+            description: obj.description,
+            jsDocTags: obj.jsDocTags,
+
+            index: obj.index,
+            validated: obj.validated,
+            recursive: obj.recursive,
+            nullables: obj.nullables.slice(),
+        });
+    }
+
+    /**
+     * @internal
+     */
+    public _Messagable(): boolean {
+        return (
+            this.properties.length >= 1 &&
+            this.properties.every((p) => p.key.isSoleLiteral())
+        );
+    }
+
+    /**
+     * @internal
+     */
+    public _Is_simple(level: number = 0): boolean {
+        return (
+            this.recursive === false &&
+            this.properties.length < 10 &&
+            this.properties.every(
+                (property) =>
+                    property.key.isSoleLiteral() &&
+                    property.value.size() === 1 &&
+                    property.value.isRequired() === true &&
+                    property.value.nullable === false &&
+                    (property.value.atomics.length === 1 ||
+                        (level < 1 &&
+                            property.value.objects.length === 1 &&
+                            property.value.objects[0]!._Is_simple(level + 1))),
+            )
+        );
+    }
+
+    public toJSON(): IMetadataObject {
+        return {
+            name: this.name,
+            properties: this.properties.map((property) => property.toJSON()),
+            description: this.description,
+            jsDocTags: this.jsDocTags,
+
+            index: this.index,
+            validated: this.validated,
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}
+
+/**
+ * @internal
+ */
+export namespace MetadataObject {
+    export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
+        x.properties.some(
+            (prop) =>
+                y.properties.find(
+                    (oppo) => prop.key.getName() === oppo.key.getName(),
+                ) !== undefined,
+        );
+
+    export const covers = (x: MetadataObject, y: MetadataObject): boolean =>
+        x.properties.length >= y.properties.length &&
+        x.properties.every(
+            (prop) =>
+                y.properties.find(
+                    (oppo) => prop.key.getName() === oppo.key.getName(),
+                ) !== undefined,
+        );
+}

package/src/schemas/metadata/MetadataProperty.ts

@@ -1,59 +1,59 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataDictionary } from "./IMetadataDictionary";
-import { IMetadataProperty } from "./IMetadataProperty";
-import { Metadata } from "./Metadata";
-
-export class MetadataProperty {
-    public readonly key: Metadata;
-    public readonly value: Metadata;
-    public readonly description: string | null;
-    public readonly jsDocTags: IJsDocTagInfo[];
-
-    /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-    /**
-     * @hidden
-     */
-    private constructor(props: ClassProperties<MetadataProperty>) {
-        this.key = props.key;
-        this.value = props.value;
-        this.description = props.description;
-        this.jsDocTags = props.jsDocTags;
-    }
-
-    /**
-     * @internal
-     */
-    public static create(
-        props: ClassProperties<MetadataProperty>,
-    ): MetadataProperty {
-        return new MetadataProperty(props);
-    }
-
-    /**
-     * @internal
-     */
-    public static _From(
-        property: IMetadataProperty,
-        dict: IMetadataDictionary,
-    ) {
-        return this.create({
-            key: Metadata._From(property.key, dict),
-            value: Metadata._From(property.value, dict),
-            description: property.description,
-            jsDocTags: property.jsDocTags.slice(),
-        });
-    }
-
-    public toJSON(): IMetadataProperty {
-        return {
-            key: this.key.toJSON(),
-            value: this.value.toJSON(),
-            description: this.description,
-            jsDocTags: this.jsDocTags,
-        };
-    }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataProperty } from "./IMetadataProperty";
+import { Metadata } from "./Metadata";
+
+export class MetadataProperty {
+    public readonly key: Metadata;
+    public readonly value: Metadata;
+    public readonly description: string | null;
+    public readonly jsDocTags: IJsDocTagInfo[];
+
+    /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataProperty>) {
+        this.key = props.key;
+        this.value = props.value;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(
+        props: ClassProperties<MetadataProperty>,
+    ): MetadataProperty {
+        return new MetadataProperty(props);
+    }
+
+    /**
+     * @internal
+     */
+    public static _From(
+        property: IMetadataProperty,
+        dict: IMetadataDictionary,
+    ) {
+        return this.create({
+            key: Metadata._From(property.key, dict),
+            value: Metadata._From(property.value, dict),
+            description: property.description,
+            jsDocTags: property.jsDocTags.slice(),
+        });
+    }
+
+    public toJSON(): IMetadataProperty {
+        return {
+            key: this.key.toJSON(),
+            value: this.value.toJSON(),
+            description: this.description,
+            jsDocTags: this.jsDocTags,
+        };
+    }
+}

package/src/schemas/metadata/MetadataTuple.ts

@@ -1,32 +1,32 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataTuple } from "./IMetadataTuple";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-import { MetadataTupleType } from "./MetadataTupleType";
-
-export class MetadataTuple {
-    public readonly type: MetadataTupleType;
-    public readonly tags: IMetadataTypeTag[][];
-
-    /**
-     * @hidden
-     */
-    private constructor(props: ClassProperties<MetadataTuple>) {
-        this.type = props.type;
-        this.tags = props.tags;
-    }
-
-    /**
-     * @internal
-     */
-    public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
-        return new MetadataTuple(props);
-    }
-
-    public toJSON(): IMetadataTuple {
-        return {
-            type: this.type.toJSON(),
-            tags: this.tags.map((row) => row.slice()),
-        };
-    }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTuple } from "./IMetadataTuple";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataTupleType } from "./MetadataTupleType";
+
+export class MetadataTuple {
+    public readonly type: MetadataTupleType;
+    public readonly tags: IMetadataTypeTag[][];
+
+    /**
+     * @hidden
+     */
+    private constructor(props: ClassProperties<MetadataTuple>) {
+        this.type = props.type;
+        this.tags = props.tags;
+    }
+
+    /**
+     * @internal
+     */
+    public static create(props: ClassProperties<MetadataTuple>): MetadataTuple {
+        return new MetadataTuple(props);
+    }
+
+    public toJSON(): IMetadataTuple {
+        return {
+            type: this.type.toJSON(),
+            tags: this.tags.map((row) => row.slice()),
+        };
+    }
+}

package/src/schemas/metadata/MetadataTupleType.ts

@@ -1,67 +1,67 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IMetadataTupleType } from "./IMetadataTupleType";
-import { Metadata } from "./Metadata";
-
-export class MetadataTupleType {
-    public readonly name: string;
-    public readonly elements: Metadata[];
-
-    public readonly index: number | null;
-    public readonly recursive: boolean;
-    public readonly nullables: boolean[];
-
-    /**
-     * @internal
-     */
-    public of_map?: boolean;
-
-    /**
-     * @internal
-     */
-    private constructor(props: ClassProperties<MetadataTupleType>) {
-        this.name = props.name;
-        this.elements = props.elements;
-        this.index = props.index;
-        this.recursive = props.recursive;
-        this.nullables = props.nullables;
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_elements(
-        props: Omit<IMetadataTupleType, "elements">,
-    ): MetadataTupleType {
-        return this.create({
-            name: props.name,
-            index: props.index,
-            elements: null!,
-            recursive: props.recursive,
-            nullables: props.nullables.slice(),
-        });
-    }
-
-    public static create(
-        props: ClassProperties<MetadataTupleType>,
-    ): MetadataTupleType {
-        return new MetadataTupleType(props);
-    }
-
-    public isRest(): boolean {
-        return (
-            this.elements.length > 0 &&
-            this.elements[this.elements.length - 1]!.rest !== null
-        );
-    }
-
-    public toJSON(): IMetadataTupleType {
-        return {
-            name: this.name,
-            index: this.index,
-            elements: this.elements.map((elem) => elem.toJSON()),
-            recursive: this.recursive,
-            nullables: this.nullables.slice(),
-        };
-    }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { Metadata } from "./Metadata";
+
+export class MetadataTupleType {
+    public readonly name: string;
+    public readonly elements: Metadata[];
+
+    public readonly index: number | null;
+    public readonly recursive: boolean;
+    public readonly nullables: boolean[];
+
+    /**
+     * @internal
+     */
+    public of_map?: boolean;
+
+    /**
+     * @internal
+     */
+    private constructor(props: ClassProperties<MetadataTupleType>) {
+        this.name = props.name;
+        this.elements = props.elements;
+        this.index = props.index;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+
+    /**
+     * @internal
+     */
+    public static _From_without_elements(
+        props: Omit<IMetadataTupleType, "elements">,
+    ): MetadataTupleType {
+        return this.create({
+            name: props.name,
+            index: props.index,
+            elements: null!,
+            recursive: props.recursive,
+            nullables: props.nullables.slice(),
+        });
+    }
+
+    public static create(
+        props: ClassProperties<MetadataTupleType>,
+    ): MetadataTupleType {
+        return new MetadataTupleType(props);
+    }
+
+    public isRest(): boolean {
+        return (
+            this.elements.length > 0 &&
+            this.elements[this.elements.length - 1]!.rest !== null
+        );
+    }
+
+    public toJSON(): IMetadataTupleType {
+        return {
+            name: this.name,
+            index: this.index,
+            elements: this.elements.map((elem) => elem.toJSON()),
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}

package/src/tags/ExclusiveMaximum.ts

@@ -1,13 +1,13 @@
-import { TagBase } from "./TagBase";
-
-export type ExclusiveMaximum<Value extends number | bigint> = TagBase<{
-    target: Value extends number ? "number" : "bigint";
-    kind: "exclusiveMaximum";
-    value: Value;
-    validate: `$input < ${Numeric<Value>}`;
-    exclusive: ["exclusiveMaximum", "maximum"];
-}>;
-
-type Numeric<Value extends number | bigint> = Value extends number
-    ? Value
-    : `BigInt(${Value})`;
+import { TagBase } from "./TagBase";
+
+export type ExclusiveMaximum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "exclusiveMaximum";
+    value: Value;
+    validate: `$input < ${Numeric<Value>}`;
+    exclusive: ["exclusiveMaximum", "maximum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;

package/src/tags/ExclusiveMinimum.ts

@@ -1,13 +1,13 @@
-import { TagBase } from "./TagBase";
-
-export type ExclusiveMinimum<Value extends number | bigint> = TagBase<{
-    target: Value extends number ? "number" : "bigint";
-    kind: "exclusiveMinimum";
-    value: Value;
-    validate: `${Numeric<Value>} < $input`;
-    exclusive: ["exclusiveMinimum", "minimum"];
-}>;
-
-type Numeric<Value extends number | bigint> = Value extends number
-    ? Value
-    : `BigInt(${Value})`;
+import { TagBase } from "./TagBase";
+
+export type ExclusiveMinimum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "exclusiveMinimum";
+    value: Value;
+    validate: `${Numeric<Value>} < $input`;
+    exclusive: ["exclusiveMinimum", "minimum"];
+}>;
+
+type Numeric<Value extends number | bigint> = Value extends number
+    ? Value
+    : `BigInt(${Value})`;