typia 4.0.0-dev.20230517 → 4.0.0-dev.20230519

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

@@ -1,148 +1,152 @@
-import { JSDocTagInfo } from "typescript";
-import ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-import { TsSymbolUtil } from "../../../utils/TsSymbolUtil";
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataTagFactory } from "../../MetadataTagFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_object =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (parent: ts.Type, nullable: boolean): MetadataObject => {
-        // EMPLACE OBJECT
-        const [obj, newbie] = collection.emplace(checker, parent);
-        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
-        if (newbie === false) return obj;
-
-        // PREPARE ASSETS
-        const pred: (node: ts.Declaration) => boolean = TsTypeUtil.isClass(
-            parent,
-        )
-            ? (node) =>
-                  ts.isPropertyDeclaration(node) &&
-                  node.modifiers !== undefined &&
-                  node.modifiers.every(
-                      (mod) =>
-                          mod.kind !== ts.SyntaxKind.PrivateKeyword &&
-                          mod.kind !== ts.SyntaxKind.ProtectedKeyword &&
-                          mod.kind !== ts.SyntaxKind.StaticKeyword &&
-                          (ts.isParameter(node) || isProperty(node)),
-                  )
-            : (node) => isProperty(node);
-
-        const insert =
-            (key: Metadata) =>
-            (value: Metadata) =>
-            (identifier: () => string) =>
-            (
-                symbol: ts.Symbol | undefined,
-                filter?: (doc: JSDocTagInfo) => boolean,
-            ): MetadataProperty => {
-                // COMMENTS AND TAGS
-                const description: string | undefined = symbol
-                    ? TsSymbolUtil.comments(symbol)
-                    : undefined;
-                const jsDocTags: JSDocTagInfo[] = (
-                    (symbol
-                        ? TsSymbolUtil.getCommentTags(symbol)
-                        : undefined) ?? []
-                ).filter(filter ?? (() => true));
-
-                // THE PROPERTY
-                const property = MetadataProperty.create({
-                    key,
-                    value,
-                    description,
-                    jsDocTags,
-                    tags: MetadataTagFactory.generate(value)(jsDocTags)(() =>
-                        identifier(),
-                    ),
-                });
-                obj.properties.push(property);
-                return property;
-            };
-
-        //----
-        // REGULAR PROPERTIES
-        //----
-        for (const prop of checker.getAugmentedPropertiesOfType(parent)) {
-            // CHECK NODE IS A FORMAL PROPERTY
-            const [node, type] = (() => {
-                const node = (prop.declarations ?? [])[0] as
-                    | ts.PropertyDeclaration
-                    | undefined;
-                const type: ts.Type | undefined = node
-                    ? checker.getTypeOfSymbolAtLocation(prop, node)
-                    : "getTypeOfPropertyOfType" in checker
-                    ? (checker as any).getTypeOfPropertyOfType(
-                          parent,
-                          checker.getFullyQualifiedName(prop),
-                      )
-                    : undefined;
-                return [node, type];
-            })();
-            if ((node && pred(node) === false) || type === undefined) continue;
-
-            // CHECK INTERNAL TAG
-            const tagList = node ? ts.getJSDocTags(node) : [];
-            if (tagList.find((tag) => tag.tagName.escapedText === "internal"))
-                continue;
-
-            // GET EXACT TYPE
-            const key: Metadata = MetadataHelper.literal_to_metadata(
-                checker.getFullyQualifiedName(prop),
-            );
-            const value: Metadata = explore_metadata(checker)(options)(
-                collection,
-            )(type, false);
-
-            // INSERT WITH REQUIRED CONFIGURATION
-            if (node?.questionToken) {
-                Writable(value).required = false;
-                Writable(value).optional = true;
-            }
-            insert(key)(value)(
-                () => `${obj.name}.${checker.getFullyQualifiedName(prop)}`,
-            )(prop);
-        }
-
-        //----
-        // DYNAMIC PROPERTIES
-        //----
-        for (const index of checker.getIndexInfosOfType(parent)) {
-            // GET EXACT TYPE
-            const analyzer = (type: ts.Type) =>
-                explore_metadata(checker)(options)(collection)(type, false);
-            const key: Metadata = analyzer(index.keyType);
-            const value: Metadata = analyzer(index.type);
-
-            // INSERT WITH REQUIRED CONFIGURATION
-            insert(key)(value)(() => `${obj.name}[${key.getName()}]`)(
-                index.declaration?.parent
-                    ? checker.getSymbolAtLocation(index.declaration.parent)
-                    : undefined,
-                (doc) => doc.name !== "default",
-            );
-        }
-
-        return obj;
-    };
-
-const isProperty = (node: ts.Declaration) =>
-    ts.isPropertyDeclaration(node) ||
-    ts.isPropertyAssignment(node) ||
-    ts.isPropertySignature(node) ||
-    ts.isTypeLiteralNode(node);
+import { JSDocTagInfo } from "typescript";
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { IProject } from "../../../transformers/IProject";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TsSymbolUtil } from "../../../utils/TsSymbolUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTagFactory } from "../../MetadataTagFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_object =
+    ({ tsc, checker }: IProject.IModule) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (parent: ts.Type, nullable: boolean): MetadataObject => {
+        // EMPLACE OBJECT
+        const [obj, newbie] = collection.emplace({ tsc, checker }, parent);
+        ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+        if (newbie === false) return obj;
+
+        // PREPARE ASSETS
+        const pred: (node: ts.Declaration) => boolean = TsTypeUtil.isClass(tsc)(
+            parent,
+        )
+            ? (node) =>
+                  (tsc.isPropertyDeclaration(node) || tsc.isParameter(node)) &&
+                  node.modifiers !== undefined &&
+                  node.modifiers.every(
+                      (mod) =>
+                          mod.kind !== tsc.SyntaxKind.PrivateKeyword &&
+                          mod.kind !== tsc.SyntaxKind.ProtectedKeyword &&
+                          mod.kind !== tsc.SyntaxKind.StaticKeyword &&
+                          (tsc.isParameter(node) || isProperty(tsc)(node)),
+                  )
+            : (node) => isProperty(tsc)(node);
+
+        const insert =
+            (key: Metadata) =>
+            (value: Metadata) =>
+            (identifier: () => string) =>
+            (
+                symbol: ts.Symbol | undefined,
+                filter?: (doc: JSDocTagInfo) => boolean,
+            ): MetadataProperty => {
+                // COMMENTS AND TAGS
+                const description: string | undefined = symbol
+                    ? TsSymbolUtil.comments(tsc)(symbol)
+                    : undefined;
+                const jsDocTags: JSDocTagInfo[] = (
+                    (symbol
+                        ? TsSymbolUtil.getCommentTags(tsc)(symbol)
+                        : undefined) ?? []
+                ).filter(filter ?? (() => true));
+
+                // THE PROPERTY
+                const property = MetadataProperty.create({
+                    key,
+                    value,
+                    description,
+                    jsDocTags,
+                    tags: MetadataTagFactory.generate(value)(jsDocTags)(() =>
+                        identifier(),
+                    ),
+                });
+                obj.properties.push(property);
+                return property;
+            };
+
+        //----
+        // REGULAR PROPERTIES
+        //----
+        for (const prop of checker.getAugmentedPropertiesOfType(parent)) {
+            // CHECK NODE IS A FORMAL PROPERTY
+            const [node, type] = (() => {
+                const node = (prop.declarations ?? [])[0] as
+                    | ts.PropertyDeclaration
+                    | undefined;
+                const type: ts.Type | undefined = node
+                    ? checker.getTypeOfSymbolAtLocation(prop, node)
+                    : "getTypeOfPropertyOfType" in checker
+                    ? (checker as any).getTypeOfPropertyOfType(
+                          parent,
+                          prop.escapedName.toString(),
+                      )
+                    : undefined;
+                return [node, type];
+            })();
+            if ((node && pred(node) === false) || type === undefined) continue;
+
+            // CHECK INTERNAL TAG
+            const tagList = node ? tsc.getJSDocTags(node) : [];
+            if (tagList.find((tag) => tag.tagName.escapedText === "internal"))
+                continue;
+
+            // GET EXACT TYPE
+            const key: Metadata = MetadataHelper.literal_to_metadata(
+                prop.escapedName.toString(),
+            );
+            const value: Metadata = explore_metadata({ tsc, checker })(options)(
+                collection,
+            )(false)(type);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            if (node?.questionToken) {
+                Writable(value).required = false;
+                Writable(value).optional = true;
+            }
+            insert(key)(value)(
+                () => `${obj.name}.${prop.escapedName.toString()}`,
+            )(prop);
+        }
+
+        //----
+        // DYNAMIC PROPERTIES
+        //----
+        for (const index of checker.getIndexInfosOfType(parent)) {
+            // GET EXACT TYPE
+            const analyzer = (type: ts.Type) =>
+                explore_metadata({ tsc, checker })(options)(collection)(false)(
+                    type,
+                );
+            const key: Metadata = analyzer(index.keyType);
+            const value: Metadata = analyzer(index.type);
+
+            // INSERT WITH REQUIRED CONFIGURATION
+            insert(key)(value)(() => `${obj.name}[${key.getName()}]`)(
+                index.declaration?.parent
+                    ? checker.getSymbolAtLocation(index.declaration.parent)
+                    : undefined,
+                (doc) => doc.name !== "default",
+            );
+        }
+
+        return obj;
+    };
+
+const isProperty = (tsc: typeof ts) => (node: ts.Declaration) =>
+    tsc.isPropertyDeclaration(node) ||
+    tsc.isPropertyAssignment(node) ||
+    tsc.isPropertySignature(node) ||
+    tsc.isTypeLiteralNode(node);

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

@@ -1,92 +1,93 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type | null, parentResolved: boolean): Metadata => {
-        // CONSTRUCT METADATA
-        const meta: Metadata = Metadata.initialize(parentResolved);
-        if (type !== null)
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                type,
-                parentResolved,
-            );
-
-        // SORT OBJECTS
-        if (meta.objects.length > 1) {
-            meta.objects.sort((x, y) =>
-                MetadataObject.covers(x, y)
-                    ? -1
-                    : MetadataObject.covers(y, x)
-                    ? 1
-                    : 0,
-            );
-            if (parentResolved === false)
-                meta.union_index = collection.getUnionIndex(meta);
-        }
-
-        // SORT ARRAYS AND TUPLES
-        if (meta.arrays.length > 1)
-            meta.arrays.sort((x, y) =>
-                Metadata.covers(x, y) ? -1 : Metadata.covers(y, x) ? 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;
-            });
-
-        // EMEND ATOMICS
-        for (const type of meta.atomics) {
-            const index: number = meta.constants.findIndex(
-                (c) => c.type === type,
-            );
-            if (index !== -1) meta.constants.splice(index, 1);
-        }
-
-        // EMEND BOOLEAN
-        {
-            const index: number = meta.constants.findIndex(
-                (c) => c.type === "boolean",
-            );
-            if (index !== -1 && meta.constants[index]!.values.length === 2) {
-                meta.constants.splice(index, 1);
-                ArrayUtil.take(
-                    meta.atomics,
-                    (type) => type === "boolean",
-                    () => "boolean",
-                );
-            }
-        }
-
-        // EMEND TEMPLATE
-        if (
-            meta.templates.length &&
-            meta.atomics.find((type) => type === "string") !== undefined
-        )
-            meta.templates.splice(0, meta.templates.length);
-
-        // RETURNS WITH VALIDATION
-        if (options.validate) options.validate(meta);
-        return meta;
-    };
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProject } from "../../../transformers/IProject";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+    (project: IProject.IModule) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (parentResolved: boolean) =>
+    (type: ts.Type | null): Metadata => {
+        // CONSTRUCT METADATA
+        const meta: Metadata = Metadata.initialize(parentResolved);
+        if (type !== null)
+            iterate_metadata(project)(options)(collection)(parentResolved)(
+                meta,
+            )(type);
+
+        // SORT OBJECTS
+        if (meta.objects.length > 1) {
+            meta.objects.sort((x, y) =>
+                MetadataObject.covers(x, y)
+                    ? -1
+                    : MetadataObject.covers(y, x)
+                    ? 1
+                    : 0,
+            );
+            if (parentResolved === false)
+                meta.union_index = collection.getUnionIndex(meta);
+        }
+
+        // SORT ARRAYS AND TUPLES
+        if (meta.arrays.length > 1)
+            meta.arrays.sort((x, y) =>
+                Metadata.covers(x, y) ? -1 : Metadata.covers(y, x) ? 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;
+            });
+
+        // EMEND ATOMICS
+        for (const type of meta.atomics) {
+            const index: number = meta.constants.findIndex(
+                (c) => c.type === type,
+            );
+            if (index !== -1) meta.constants.splice(index, 1);
+        }
+
+        // EMEND BOOLEAN
+        {
+            const index: number = meta.constants.findIndex(
+                (c) => c.type === "boolean",
+            );
+            if (index !== -1 && meta.constants[index]!.values.length === 2) {
+                meta.constants.splice(index, 1);
+                ArrayUtil.take(
+                    meta.atomics,
+                    (type) => type === "boolean",
+                    () => "boolean",
+                );
+            }
+        }
+
+        // EMEND TEMPLATE
+        if (
+            meta.templates.length &&
+            meta.atomics.find((type) => type === "string") !== undefined
+        )
+            meta.templates.splice(0, meta.templates.length);
+
+        // RETURNS WITH VALIDATION
+        if (options.validate) options.validate(meta);
+        return meta;
+    };

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

@@ -1,69 +1,63 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
-// import { ArrayUtil } from "../../../utils/ArrayUtil";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata_array } from "./iterate_metadata_array";
-import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-import { iterate_metadata_constant } from "./iterate_metadata_constant";
-import { iterate_metadata_map } from "./iterate_metadata_map";
-import { iterate_metadata_native } from "./iterate_metadata_native";
-import { iterate_metadata_object } from "./iterate_metadata_object";
-import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
-import { iterate_metadata_set } from "./iterate_metadata_set";
-import { iterate_metadata_template } from "./iterate_metadata_template";
-import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
-import { iterate_metadata_union } from "./iterate_metadata_union";
-
-export const iterate_metadata =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): void => {
-        if (TsTypeUtil.isTypeParameter(type) === true)
-            throw new Error(
-                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
-            );
-
-        // CHECK UNION & toJSON()
-        if (
-            iterate_metadata_union(checker)(options)(collection)(
-                meta,
-                type,
-                parentResolved,
-            ) ||
-            iterate_metadata_resolve(checker)(options)(collection)(
-                meta,
-                type,
-                parentResolved,
-            )
-        )
-            return;
-
-        // ITERATE CASES
-        iterate_metadata_coalesce(meta, type) ||
-            iterate_metadata_constant(checker)(options)(meta, type) ||
-            iterate_metadata_template(checker)(options)(collection)(
-                meta,
-                type,
-            ) ||
-            iterate_metadata_atomic(meta, type) ||
-            iterate_metadata_tuple(checker)(options)(collection)(
-                meta,
-                type as ts.TupleType,
-            ) ||
-            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_native(checker)(meta, type) ||
-            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_object(checker)(options)(collection)(
-                meta,
-                type,
-                parentResolved,
-            );
-    };
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProject } from "../../../transformers/IProject";
+
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
+// import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_map } from "./iterate_metadata_map";
+import { iterate_metadata_native } from "./iterate_metadata_native";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
+import { iterate_metadata_set } from "./iterate_metadata_set";
+import { iterate_metadata_template } from "./iterate_metadata_template";
+import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
+import { iterate_metadata_union } from "./iterate_metadata_union";
+
+export const iterate_metadata =
+    (p: IProject.IModule) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (parentResolved: boolean) =>
+    (meta: Metadata) =>
+    (type: ts.Type): void => {
+        if (TsTypeUtil.isTypeParameter(p.tsc)(type) === true)
+            throw new Error(
+                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
+            );
+
+        // CHECK UNION & toJSON()
+        if (
+            iterate_metadata_union(p)(options)(collection)(parentResolved)(
+                meta,
+            )(type) ||
+            iterate_metadata_resolve(p)(options)(collection)(parentResolved)(
+                meta,
+            )(type)
+        )
+            return;
+
+        // ITERATE CASES
+        iterate_metadata_coalesce(p.tsc)(meta)(type) ||
+            iterate_metadata_constant(p)(options)(meta)(type) ||
+            iterate_metadata_template(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_atomic(p.tsc)(meta)(type) ||
+            iterate_metadata_tuple(p)(options)(collection)(meta)(
+                type as ts.TupleType,
+            ) ||
+            iterate_metadata_array(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_native(p)(meta)(type) ||
+            iterate_metadata_map(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_set(p)(options)(collection)(meta)(type) ||
+            iterate_metadata_object(p)(options)(collection)(parentResolved)(
+                meta,
+            )(type);
+    };