typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

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

@@ -1,9 +1,7 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
 
-import { IProject } from "../../../transformers/IProject";
-
 import { Writable } from "../../../typings/Writable";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -12,17 +10,16 @@ import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_resolve =
-    (p: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (parentResolved: boolean) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
         if (options.resolve === true && parentResolved === false) {
-            const resolved: ts.Type | null = TypeFactory.resolve(p)(type);
+            const resolved: ts.Type | null = TypeFactory.resolve(checker)(type);
             if (resolved !== null) {
-                Writable(meta).resolved =
-                    explore_metadata(p)(options)(collection)(true)(resolved);
+                Writable(meta).resolved = explore_metadata(checker)(options)(
+                    collection,
+                )(resolved, true);
                 return true;
             }
         }

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

@@ -1,9 +1,7 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
 
-import { IProject } from "../../../transformers/IProject";
-
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -12,24 +10,23 @@ import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_set =
-    (p: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        type = p.checker.getApparentType(type);
+    (meta: Metadata, type: ts.Type): boolean => {
+        type = checker.getApparentType(type);
 
-        const name = TypeFactory.getFullName(p)(type, type.symbol);
+        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
         const generic = type.aliasSymbol
             ? type.aliasTypeArguments
-            : p.checker.getTypeArguments(type as ts.TypeReference);
+            : checker.getTypeArguments(type as ts.TypeReference);
         if (name.substring(0, 4) !== "Set<" || generic?.length !== 1)
             return false;
 
         const key: ts.Type = generic[0]!;
         ArrayUtil.set(
             meta.sets,
-            explore_metadata(p)(options)(collection)(false)(key),
+            explore_metadata(checker)(options)(collection)(key, false),
             (elem) => elem.getName(),
         );
         return true;

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

@@ -0,0 +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;
+            });
+    };

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

@@ -1,22 +1,19 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
 
-import { IProject } from "../../../transformers/IProject";
-
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_template =
-    ({ tsc, checker }: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
-        if (!filter(tsc.TypeFlags.TemplateLiteral)) return false;
+    (meta: Metadata, type: ts.Type): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+        if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
         const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
         const row: Metadata[] = [];
@@ -29,9 +26,10 @@ export const iterate_metadata_template =
             const binded: ts.Type | undefined = template.types[i];
             if (binded)
                 row.push(
-                    explore_metadata({ tsc, checker })(options)(collection)(
+                    explore_metadata(checker)(options)(collection)(
+                        binded,
                         false,
-                    )(binded),
+                    ),
                 );
         });
         meta.templates.push(row);

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

@@ -1,51 +1,24 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
-
-import { IProject } from "../../../transformers/IProject";
-
-import { Writable } from "../../../typings/Writable";
+import { MetadataTuple } from "../../../metadata/MetadataTuple";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
+import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
 
 export const iterate_metadata_tuple =
-    ({ tsc, checker }: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata) =>
-    (type: ts.TupleType): boolean => {
+    (meta: Metadata, type: ts.TupleType): boolean => {
         if (!checker.isTupleType(type)) return false;
 
-        const elementFlags: readonly ts.ElementFlags[] =
-            type.elementFlags ??
-            (type.target as ts.TupleType)?.elementFlags ??
-            [];
-
-        const children: Metadata[] = checker
-            .getTypeArguments(type as ts.TypeReference)
-            .map((elem, i) => {
-                const child: Metadata = explore_metadata({ tsc, checker })(
-                    options,
-                )(collection)(false)(elem);
-
-                // CHECK OPTIONAL
-                const flag: ts.ElementFlags | undefined = elementFlags[i];
-                if (flag === tsc.ElementFlags.Optional)
-                    Writable(child).optional = true;
-
-                // REST TYPE
-                if (flag !== tsc.ElementFlags.Rest) return child;
-                const wrapper: Metadata = Metadata.initialize();
-                Writable(wrapper).rest = child;
-                return wrapper;
-            });
-        ArrayUtil.set(meta.tuples, children, join_tuple_names);
+        const tuple: MetadataTuple = emplace_metadata_tuple(checker)(options)(
+            collection,
+        )(type, meta.nullable);
+        ArrayUtil.add(meta.tuples, tuple, (elem) => elem.name === tuple.name);
         return true;
     };
-
-const join_tuple_names = (metas: Metadata[]): string =>
-    `[${metas.map((m) => m.getName).join(", ")}]`;

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

@@ -1,42 +1,41 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
 
-import { IProject } from "../../../transformers/IProject";
-
 import { Writable } from "../../../typings/Writable";
 
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const iterate_metadata_union =
-    (p: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (parentResolved: boolean) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        if (!TsTypeUtil.isUnion(p.tsc)(type)) return false;
+    (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(p)(options)(collection)(false)(meta)(t),
+                iterate_metadata(checker)(options)(collection)(
+                    meta,
+                    t,
+                    false,
+                    false,
+                ),
             );
             return true;
         }
 
         const filter = (flag: ts.TypeFlags, t: ts.Type) =>
-            (t.flags & flag) !== 0;
+            (t.getFlags() & flag) !== 0;
         const normals: ts.Type[] = [];
         const toJsons: ts.Type[] = [];
 
         for (const individual of type.types) {
-            if (filter(p.tsc.TypeFlags.Object, individual)) {
+            if (filter(ts.TypeFlags.Object, individual)) {
                 const resolved: ts.Type | null =
-                    TypeFactory.resolve(p)(individual);
+                    TypeFactory.resolve(checker)(individual);
                 if (resolved !== null) toJsons.push(resolved);
                 else normals.push(individual);
             } else normals.push(individual);
@@ -45,7 +44,12 @@ export const iterate_metadata_union =
             Writable(meta).resolved = (() => {
                 const union: Metadata = Metadata.initialize();
                 toJsons.forEach((t) =>
-                    iterate_metadata(p)(options)(collection)(true)(meta)(t),
+                    iterate_metadata(checker)(options)(collection)(
+                        meta,
+                        t,
+                        true,
+                        false,
+                    ),
                 );
                 if (union.objects.length > 1)
                     union.union_index = collection.getUnionIndex(union);
@@ -53,7 +57,12 @@ export const iterate_metadata_union =
             })();
         }
         normals.forEach((t) =>
-            iterate_metadata(p)(options)(collection)(false)(meta)(t),
+            iterate_metadata(checker)(options)(collection)(
+                meta,
+                t,
+                false,
+                false,
+            ),
         );
         return true;
     };

package/src/metadata/IMetadata.ts

@@ -16,9 +16,10 @@ export interface IMetadata {
     resolved: IMetadata | null;
 
     rest: IMetadata | null;
-    arrays: IMetadata[];
-    tuples: IMetadata[][];
+    arrays: string[];
+    tuples: string[];
     objects: string[];
+    aliases: string[];
 
     natives: string[];
     sets: IMetadata[];

package/src/metadata/IMetadataAlias.ts

@@ -0,0 +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[];
+}

package/src/metadata/IMetadataApplication.ts

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

package/src/metadata/IMetadataArray.ts

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

package/src/metadata/IMetadataCollection.ts

@@ -0,0 +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[];
+}

package/src/metadata/IMetadataDictionary.ts

@@ -0,0 +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>;
+}

package/src/metadata/IMetadataObject.ts

@@ -7,23 +7,12 @@ export interface IMetadataObject {
     description?: string;
     jsDocTags: IJsDocTagInfo[];
 
-    /**
-     * @internal
-     */
     index: number;
-
-    /**
-     * @internal
-     */
-    validated: boolean;
-
-    /**
-     * @internal
-     */
     recursive: boolean;
+    nullables: boolean[];
 
     /**
      * @internal
      */
-    nullables: boolean[];
+    validated: boolean;
 }

package/src/metadata/IMetadataProperty.ts

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

package/src/metadata/IMetadataTuple.ts

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