typia 4.0.0-dev.20230604 → 4.0.0

package/src/factories/internal/metadata/iterate_metadata_sort.ts

@@ -1,68 +1,68 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { MetadataCollection } from "../../MetadataCollection";
-
-export const iterate_metadata_sort =
-    (collection: MetadataCollection) => (meta: Metadata) => {
-        const visited: Set<Metadata> = new Set();
-        for (const array of collection.arrays())
-            iterate(visited)(collection)(array.value);
-        for (const tuple of collection.tuples())
-            for (const element of tuple.elements)
-                iterate(visited)(collection)(element);
-        for (const object of collection.objects())
-            for (const property of object.properties)
-                iterate(visited)(collection)(property.value);
-        iterate(visited)(collection)(meta);
-    };
-
-const iterate =
-    (visited: Set<Metadata>) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata) => {
-        if (visited.has(meta)) return;
-        visited.add(meta);
-
-        // ITERATE CHILDREN
-        for (const map of meta.maps) iterate(visited)(collection)(map.value);
-        for (const set of meta.sets) iterate(visited)(collection)(set);
-        if (meta.resolved !== null) iterate(visited)(collection)(meta.resolved);
-        if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
-
-        // SORT OBJECTS
-        if (meta.objects.length > 1) {
-            meta.objects.sort((x, y) =>
-                MetadataObject.covers(x, y)
-                    ? -1
-                    : MetadataObject.covers(y, x)
-                    ? 1
-                    : 0,
-            );
-            meta.union_index = collection.getUnionIndex(meta);
-        }
-
-        // SORT ARRAYS AND TUPLES
-        if (meta.arrays.length > 1)
-            meta.arrays.sort((x, y) =>
-                Metadata.covers(x.value, y.value)
-                    ? -1
-                    : Metadata.covers(y.value, x.value)
-                    ? 1
-                    : 0,
-            );
-        if (meta.tuples.length > 1)
-            meta.tuples.sort((x, y) => {
-                const xt = Metadata.initialize();
-                const yt = Metadata.initialize();
-
-                xt.tuples.push(x);
-                yt.tuples.push(y);
-
-                return Metadata.covers(xt, yt)
-                    ? -1
-                    : Metadata.covers(yt, xt)
-                    ? 1
-                    : 0;
-            });
-    };
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { MetadataCollection } from "../../MetadataCollection";
+
+export const iterate_metadata_sort =
+    (collection: MetadataCollection) => (meta: Metadata) => {
+        const visited: Set<Metadata> = new Set();
+        for (const array of collection.arrays())
+            iterate(visited)(collection)(array.value);
+        for (const tuple of collection.tuples())
+            for (const element of tuple.elements)
+                iterate(visited)(collection)(element);
+        for (const object of collection.objects())
+            for (const property of object.properties)
+                iterate(visited)(collection)(property.value);
+        iterate(visited)(collection)(meta);
+    };
+
+const iterate =
+    (visited: Set<Metadata>) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata) => {
+        if (visited.has(meta)) return;
+        visited.add(meta);
+
+        // ITERATE CHILDREN
+        for (const map of meta.maps) iterate(visited)(collection)(map.value);
+        for (const set of meta.sets) iterate(visited)(collection)(set);
+        if (meta.resolved !== null) iterate(visited)(collection)(meta.resolved);
+        if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
+
+        // SORT OBJECTS
+        if (meta.objects.length > 1) {
+            meta.objects.sort((x, y) =>
+                MetadataObject.covers(x, y)
+                    ? -1
+                    : MetadataObject.covers(y, x)
+                    ? 1
+                    : 0,
+            );
+            meta.union_index = collection.getUnionIndex(meta);
+        }
+
+        // SORT ARRAYS AND TUPLES
+        if (meta.arrays.length > 1)
+            meta.arrays.sort((x, y) =>
+                Metadata.covers(x.value, y.value)
+                    ? -1
+                    : Metadata.covers(y.value, x.value)
+                    ? 1
+                    : 0,
+            );
+        if (meta.tuples.length > 1)
+            meta.tuples.sort((x, y) => {
+                const xt = Metadata.initialize();
+                const yt = Metadata.initialize();
+
+                xt.tuples.push(x);
+                yt.tuples.push(y);
+
+                return Metadata.covers(xt, yt)
+                    ? -1
+                    : Metadata.covers(yt, xt)
+                    ? 1
+                    : 0;
+            });
+    };

package/src/factories/internal/metadata/iterate_metadata_tuple.ts

@@ -1,25 +1,24 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataTuple } from "../../../metadata/MetadataTuple";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
-
-export const iterate_metadata_tuple =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): boolean => {
-        // @todo -> TS 5.2 supports it
-        if (!(checker as any).isTupleType(type)) return false;
-
-        const tuple: MetadataTuple = emplace_metadata_tuple(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.tuples, tuple, (elem) => elem.name === tuple.name);
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataTuple } from "../../../metadata/MetadataTuple";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
+
+export const iterate_metadata_tuple =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.TupleType): boolean => {
+        if (!checker.isTupleType(type)) return false;
+
+        const tuple: MetadataTuple = emplace_metadata_tuple(checker)(options)(
+            collection,
+        )(type, meta.nullable);
+        ArrayUtil.add(meta.tuples, tuple, (elem) => elem.name === tuple.name);
+        return true;
+    };

package/src/factories/internal/metadata/iterate_metadata_union.ts

@@ -1,68 +1,68 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_union =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        if (!type.isUnion()) return false;
-        else if (options.resolve === false || parentResolved === true) {
-            type.types.forEach((t) =>
-                iterate_metadata(checker)(options)(collection)(
-                    meta,
-                    t,
-                    false,
-                    false,
-                ),
-            );
-            return true;
-        }
-
-        const filter = (flag: ts.TypeFlags, t: ts.Type) =>
-            (t.getFlags() & flag) !== 0;
-        const normals: ts.Type[] = [];
-        const toJsons: ts.Type[] = [];
-
-        for (const individual of type.types) {
-            if (filter(ts.TypeFlags.Object, individual)) {
-                const resolved: ts.Type | null =
-                    TypeFactory.resolve(checker)(individual);
-                if (resolved !== null) toJsons.push(resolved);
-                else normals.push(individual);
-            } else normals.push(individual);
-        }
-        if (toJsons.length !== 0) {
-            Writable(meta).resolved = (() => {
-                const union: Metadata = Metadata.initialize();
-                toJsons.forEach((t) =>
-                    iterate_metadata(checker)(options)(collection)(
-                        meta,
-                        t,
-                        true,
-                        false,
-                    ),
-                );
-                if (union.objects.length > 1)
-                    union.union_index = collection.getUnionIndex(union);
-                return union;
-            })();
-        }
-        normals.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                t,
-                false,
-                false,
-            ),
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { Writable } from "../../../typings/Writable";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_union =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+        if (!type.isUnion()) return false;
+        else if (options.resolve === false || parentResolved === true) {
+            type.types.forEach((t) =>
+                iterate_metadata(checker)(options)(collection)(
+                    meta,
+                    t,
+                    false,
+                    false,
+                ),
+            );
+            return true;
+        }
+
+        const filter = (flag: ts.TypeFlags, t: ts.Type) =>
+            (t.getFlags() & flag) !== 0;
+        const normals: ts.Type[] = [];
+        const toJsons: ts.Type[] = [];
+
+        for (const individual of type.types) {
+            if (filter(ts.TypeFlags.Object, individual)) {
+                const resolved: ts.Type | null =
+                    TypeFactory.resolve(checker)(individual);
+                if (resolved !== null) toJsons.push(resolved);
+                else normals.push(individual);
+            } else normals.push(individual);
+        }
+        if (toJsons.length !== 0) {
+            Writable(meta).resolved = (() => {
+                const union: Metadata = Metadata.initialize();
+                toJsons.forEach((t) =>
+                    iterate_metadata(checker)(options)(collection)(
+                        meta,
+                        t,
+                        true,
+                        false,
+                    ),
+                );
+                if (union.objects.length > 1)
+                    union.union_index = collection.getUnionIndex(union);
+                return union;
+            })();
+        }
+        normals.forEach((t) =>
+            iterate_metadata(checker)(options)(collection)(
+                meta,
+                t,
+                false,
+                false,
+            ),
+        );
+        return true;
+    };

package/src/metadata/IMetadata.ts

@@ -1,27 +1,27 @@
-import { Atomic } from "../typings/Atomic";
-
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataEntry } from "./IMetadataEntry";
-
-export interface IMetadata {
-    any: boolean;
-    required: boolean;
-    optional: boolean;
-    nullable: boolean;
-    functional: boolean;
-
-    atomics: Atomic.Literal[];
-    constants: IMetadataConstant[];
-    templates: IMetadata[][];
-    resolved: IMetadata | null;
-
-    rest: IMetadata | null;
-    arrays: string[];
-    tuples: string[];
-    objects: string[];
-    aliases: string[];
-
-    natives: string[];
-    sets: IMetadata[];
-    maps: IMetadataEntry[];
-}
+import { Atomic } from "../typings/Atomic";
+
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEntry } from "./IMetadataEntry";
+
+export interface IMetadata {
+    any: boolean;
+    required: boolean;
+    optional: boolean;
+    nullable: boolean;
+    functional: boolean;
+
+    atomics: Atomic.Literal[];
+    constants: IMetadataConstant[];
+    templates: IMetadata[][];
+    resolved: IMetadata | null;
+
+    rest: IMetadata | null;
+    arrays: string[];
+    tuples: string[];
+    objects: string[];
+    aliases: string[];
+
+    natives: string[];
+    sets: IMetadata[];
+    maps: IMetadataEntry[];
+}

package/src/metadata/IMetadataAlias.ts

@@ -1,12 +1,12 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataAlias {
-    name: string;
-    value: IMetadata;
-
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-    recursive: boolean;
-    nullables: boolean[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataAlias {
+    name: string;
+    value: IMetadata;
+
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+    recursive: boolean;
+    nullables: boolean[];
+}

package/src/metadata/IMetadataApplication.ts

@@ -1,7 +1,7 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataCollection } from "./IMetadataCollection";
-
-export interface IMetadataApplication {
-    metadatas: IMetadata[];
-    collection: IMetadataCollection;
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataCollection } from "./IMetadataCollection";
+
+export interface IMetadataApplication {
+    metadatas: IMetadata[];
+    collection: IMetadataCollection;
+}

package/src/metadata/IMetadataArray.ts

@@ -1,10 +1,10 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataArray {
-    name: string;
-    value: IMetadata;
-
-    nullables: boolean[];
-    recursive: boolean;
-    index: number | null;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataArray {
+    name: string;
+    value: IMetadata;
+
+    nullables: boolean[];
+    recursive: boolean;
+    index: number | null;
+}

package/src/metadata/IMetadataCollection.ts

@@ -1,11 +1,11 @@
-import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArray } from "./IMetadataArray";
-import { IMetadataObject } from "./IMetadataObject";
-import { IMetadataTuple } from "./IMetadataTuple";
-
-export interface IMetadataCollection {
-    objects: IMetadataObject[];
-    aliases: IMetadataAlias[];
-    arrays: IMetadataArray[];
-    tuples: IMetadataTuple[];
-}
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataTuple } from "./IMetadataTuple";
+
+export interface IMetadataCollection {
+    objects: IMetadataObject[];
+    aliases: IMetadataAlias[];
+    arrays: IMetadataArray[];
+    tuples: IMetadataTuple[];
+}

package/src/metadata/IMetadataDictionary.ts

@@ -1,14 +1,14 @@
-import { MetadataAlias } from "./MetadataAlias";
-import { MetadataArray } from "./MetadataArray";
-import { MetadataObject } from "./MetadataObject";
-import { MetadataTuple } from "./MetadataTuple";
-
-/**
- * @internal
- */
-export interface IMetadataDictionary {
-    objects: Map<string, MetadataObject>;
-    aliases: Map<string, MetadataAlias>;
-    arrays: Map<string, MetadataArray>;
-    tuples: Map<string, MetadataTuple>;
-}
+import { MetadataAlias } from "./MetadataAlias";
+import { MetadataArray } from "./MetadataArray";
+import { MetadataObject } from "./MetadataObject";
+import { MetadataTuple } from "./MetadataTuple";
+
+/**
+ * @internal
+ */
+export interface IMetadataDictionary {
+    objects: Map<string, MetadataObject>;
+    aliases: Map<string, MetadataAlias>;
+    arrays: Map<string, MetadataArray>;
+    tuples: Map<string, MetadataTuple>;
+}

package/src/metadata/IMetadataObject.ts

@@ -1,18 +1,18 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataProperty } from "./IMetadataProperty";
-
-export interface IMetadataObject {
-    name: string;
-    properties: IMetadataProperty[];
-    description?: string;
-    jsDocTags: IJsDocTagInfo[];
-
-    index: number;
-    recursive: boolean;
-    nullables: boolean[];
-
-    /**
-     * @internal
-     */
-    validated: boolean;
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataProperty } from "./IMetadataProperty";
+
+export interface IMetadataObject {
+    name: string;
+    properties: IMetadataProperty[];
+    description?: string;
+    jsDocTags: IJsDocTagInfo[];
+
+    index: number;
+    recursive: boolean;
+    nullables: boolean[];
+
+    /**
+     * @internal
+     */
+    validated: boolean;
+}

package/src/metadata/IMetadataProperty.ts

@@ -1,11 +1,11 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
-
-export interface IMetadataProperty {
-    key: IMetadata;
-    value: IMetadata;
-    description: string | null;
-    tags: IMetadataTag[];
-    jsDocTags: IJsDocTagInfo[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+import { IMetadataTag } from "./IMetadataTag";
+
+export interface IMetadataProperty {
+    key: IMetadata;
+    value: IMetadata;
+    description: string | null;
+    tags: IMetadataTag[];
+    jsDocTags: IJsDocTagInfo[];
+}

package/src/metadata/IMetadataTuple.ts

@@ -1,10 +1,10 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataTuple {
-    name: string;
-    elements: IMetadata[];
-
-    index: number | null;
-    recursive: boolean;
-    nullables: boolean[];
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataTuple {
+    name: string;
+    elements: IMetadata[];
+
+    index: number | null;
+    recursive: boolean;
+    nullables: boolean[];
+}