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

package/src/factories/TypeFactory.ts

@@ -1,43 +1,33 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { IProject } from "../transformers/IProject";
-
-import { TsNodeUtil } from "../utils/TsNodeUtil";
-import { TsTypeUtil } from "../utils/TsTypeUtil";
+import ts from "typescript";
 
 export namespace TypeFactory {
     export const resolve =
-        (project: IProject.IModule) =>
+        (checker: ts.TypeChecker) =>
         (type: ts.Type): ts.Type | null =>
-            getReturnType(project)(type)("toJSON");
+            getReturnType(checker)(type)("toJSON");
 
-    export const isFunction =
-        (tsc: typeof ts) =>
-        (type: ts.Type): boolean =>
-            getFunction(tsc)(type) !== null;
+    export const isFunction = (type: ts.Type): boolean =>
+        getFunction(type) !== null;
 
-    const getFunction = (tsc: typeof ts) => (type: ts.Type) => {
+    const getFunction = (type: ts.Type) => {
         const node = type.symbol?.declarations?.[0];
         if (node === undefined) return null;
 
-        return tsc.isFunctionLike(node)
+        return ts.isFunctionLike(node)
             ? node
-            : tsc.isPropertyAssignment(node) || tsc.isPropertyDeclaration(node)
-            ? tsc.isFunctionLike(node.initializer)
+            : ts.isPropertyAssignment(node) || ts.isPropertyDeclaration(node)
+            ? ts.isFunctionLike(node.initializer)
                 ? node.initializer
                 : null
             : null;
     };
 
     export const getReturnType =
-        ({ tsc, checker }: IProject.IModule) =>
+        (checker: ts.TypeChecker) =>
         (type: ts.Type) =>
         (name: string): ts.Type | null => {
             // FIND TO-JSON METHOD
-            const symbol: ts.Symbol | undefined = checker.getPropertyOfType(
-                type,
-                name,
-            );
+            const symbol: ts.Symbol | undefined = type.getProperty(name);
             if (!symbol) return null;
             else if (!symbol.valueDeclaration) return null;
 
@@ -49,97 +39,86 @@ export namespace TypeFactory {
 
             // RETURNS THE RETURN-TYPE
             const signature: ts.Signature | undefined =
-                checker.getSignaturesOfType(functor, tsc.SignatureKind.Call)[0];
-            return signature
-                ? checker.getReturnTypeOfSignature(signature)
-                : null;
+                checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+            return signature ? signature.getReturnType() : null;
         };
 
     export const getFullName =
-        (p: IProject.IModule) =>
+        (checker: ts.TypeChecker) =>
         (type: ts.Type, symbol?: ts.Symbol): string => {
             // PRIMITIVE
-            symbol ??= type.aliasSymbol ?? type.symbol;
-            if (symbol === undefined) return p.checker.typeToString(type);
+            symbol ??= type.aliasSymbol ?? type.getSymbol();
+            if (symbol === undefined) return checker.typeToString(type);
 
             // UNION OR INTERSECT
             if (
                 type.aliasSymbol === undefined &&
-                TsTypeUtil.isUnionOrIntersection(p.tsc)(type)
+                type.isUnionOrIntersection()
             ) {
-                const joiner: string = TsTypeUtil.isIntersection(p.tsc)(type)
-                    ? " & "
-                    : " | ";
+                const joiner: string = type.isIntersection() ? " & " : " | ";
                 return type.types
-                    .map((child) => getFullName(p)(child))
+                    .map((child) => getFullName(checker)(child))
                     .join(joiner);
             }
 
             //----
             // SPECIALIZATION
             //----
-            const name: string = get_name(p.tsc)(symbol);
+            const name: string = get_name(symbol);
 
             // CHECK GENERIC
             const generic: readonly ts.Type[] = type.aliasSymbol
-                ? type.aliasTypeArguments ?? []
-                : p.checker.getTypeArguments(type as ts.TypeReference);
+                ? type.aliasTypeArguments || []
+                : checker.getTypeArguments(type as ts.TypeReference);
             return generic.length
                 ? name === "Promise"
-                    ? getFullName(p)(generic[0]!)
+                    ? getFullName(checker)(generic[0]!)
                     : `${name}<${generic
-                          .map((child) => getFullName(p)(child))
+                          .map((child) => getFullName(checker)(child))
                           .join(", ")}>`
                 : name;
         };
 
     const explore_name =
-        (tsc: typeof ts) =>
         (decl: ts.Node) =>
         (name: string): string =>
-            tsc.isModuleBlock(decl)
-                ? explore_name(tsc)(decl.parent.parent)(
-                      `${TsNodeUtil.getFullText(tsc)(
-                          decl.parent.name,
-                      ).trim()}.${name}`,
+            ts.isModuleBlock(decl)
+                ? explore_name(decl.parent.parent)(
+                      `${decl.parent.name.getFullText().trim()}.${name}`,
                   )
                 : name;
 
-    const get_name =
-        (tsc: typeof ts) =>
-        (symbol: ts.Symbol): string => {
-            const parent = symbol.declarations?.[0]?.parent;
-            return parent
-                ? explore_name(tsc)(parent)(symbol.escapedName.toString())
-                : "__type";
-        };
+    const get_name = (symbol: ts.Symbol): string => {
+        const parent = symbol.getDeclarations()?.[0]?.parent;
+        return parent
+            ? explore_name(parent)(symbol.escapedName.toString())
+            : "__type";
+    };
 
-    export const keyword =
-        (tsc: typeof ts) =>
-        (
-            type:
-                | "void"
-                | "any"
-                | "unknown"
-                | "boolean"
-                | "number"
-                | "bigint"
-                | "string",
-        ) => {
-            return tsc.factory.createKeywordTypeNode(
-                type === "void"
-                    ? tsc.SyntaxKind.VoidKeyword
-                    : type === "any"
-                    ? tsc.SyntaxKind.AnyKeyword
-                    : type === "unknown"
-                    ? tsc.SyntaxKind.UnknownKeyword
-                    : type === "boolean"
-                    ? tsc.SyntaxKind.BooleanKeyword
-                    : type === "number"
-                    ? tsc.SyntaxKind.NumberKeyword
-                    : type === "bigint"
-                    ? tsc.SyntaxKind.BigIntKeyword
-                    : tsc.SyntaxKind.StringKeyword,
-            );
-        };
+    export const keyword = (
+        type:
+            | "void"
+            | "any"
+            | "unknown"
+            | "boolean"
+            | "number"
+            | "bigint"
+            | "string",
+    ) => {
+        return ts.factory.createKeywordTypeNode(
+            type === "void"
+                ? ts.SyntaxKind.VoidKeyword
+                : type === "any"
+                ? ts.SyntaxKind.AnyKeyword
+                : type === "unknown"
+                ? ts.SyntaxKind.UnknownKeyword
+                : type === "boolean"
+                ? ts.SyntaxKind.BooleanKeyword
+                : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                ? ts.SyntaxKind.BigIntKeyword
+                : ts.SyntaxKind.StringKeyword,
+        );
+    };
 }

package/src/factories/ValueFactory.ts

@@ -1,15 +1,12 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 export namespace ValueFactory {
-    export const NULL = (tsc: typeof ts) => tsc.factory.createNull();
-    export const UNDEFINED = (tsc: typeof ts) =>
-        tsc.factory.createIdentifier("undefined");
-    export const BOOLEAN = (tsc: typeof ts) => (value: boolean) =>
-        value ? tsc.factory.createTrue() : tsc.factory.createFalse();
-    export const INPUT =
-        (tsc: typeof ts) =>
-        (str: string = "input") =>
-            tsc.factory.createIdentifier(str);
-    export const TYPEOF = (tsc: typeof ts) => (input: ts.Expression) =>
-        tsc.factory.createTypeOfExpression(input);
+    export const NULL = () => ts.factory.createNull();
+    export const UNDEFINED = () => ts.factory.createIdentifier("undefined");
+    export const BOOLEAN = (value: boolean) =>
+        value ? ts.factory.createTrue() : ts.factory.createFalse();
+    export const INPUT = (str: string = "input") =>
+        ts.factory.createIdentifier(str);
+    export const TYPEOF = (input: ts.Expression) =>
+        ts.factory.createTypeOfExpression(input);
 }

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

@@ -0,0 +1,34 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataArray } from "../../../metadata/MetadataArray";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_array =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataArray => {
+        // CHECK EXISTENCE
+        const [array, newbie, setValue] = collection.emplaceArray(
+            checker,
+            type,
+        );
+        ArrayUtil.add(array.nullables, nullable);
+        if (newbie === false) return array;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type.getNumberIndexType()!,
+            false,
+            false,
+        );
+        setValue(value);
+
+        return array;
+    };

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

@@ -0,0 +1,35 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataAlias } from "../../../metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_definition =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataAlias => {
+        // CHECK EXISTENCE
+        const [alias, newbie, closure] = collection.emplaceAlias(
+            checker,
+            type,
+            type.aliasSymbol!,
+        );
+        ArrayUtil.add(alias.nullables, nullable);
+        if (newbie === false) return alias;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type,
+            false,
+            true,
+        );
+        closure(value);
+
+        return alias;
+    };

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

@@ -1,18 +1,14 @@
-import { JSDocTagInfo } from "typescript";
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 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 { CommentFactory } from "../../CommentFactory";
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { MetadataTagFactory } from "../../MetadataTagFactory";
@@ -20,30 +16,30 @@ import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 
 export const emplace_metadata_object =
-    ({ tsc, checker }: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
     (parent: ts.Type, nullable: boolean): MetadataObject => {
         // EMPLACE OBJECT
-        const [obj, newbie] = collection.emplace({ tsc, checker }, parent);
+        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(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 isClass: boolean = parent.isClass();
+        const pred: (node: ts.Declaration) => boolean = isClass
+            ? (node) => {
+                  const kind: ts.SyntaxKind | undefined = node
+                      .getChildren()[0]
+                      ?.getChildren()[0]?.kind;
+                  return (
+                      kind !== ts.SyntaxKind.PrivateKeyword &&
+                      kind !== ts.SyntaxKind.ProtectedKeyword &&
+                      (ts.isParameter(node) || isProperty(node))
+                  );
+              }
+            : (node) => isProperty(node);
 
         const insert =
             (key: Metadata) =>
@@ -51,16 +47,14 @@ export const emplace_metadata_object =
             (identifier: () => string) =>
             (
                 symbol: ts.Symbol | undefined,
-                filter?: (doc: JSDocTagInfo) => boolean,
+                filter?: (doc: ts.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) ?? []
+                const description: string | null = symbol
+                    ? CommentFactory.description(symbol) ?? null
+                    : null;
+                const jsDocTags: ts.JSDocTagInfo[] = (
+                    symbol?.getJsDocTags() ?? []
                 ).filter(filter ?? (() => true));
 
                 // THE PROPERTY
@@ -80,10 +74,18 @@ export const emplace_metadata_object =
         //----
         // REGULAR PROPERTIES
         //----
-        for (const prop of checker.getAugmentedPropertiesOfType(parent)) {
+        for (const prop of parent.getApparentProperties()) {
+            // CHECK INTERNAL TAG
+            if (
+                (prop.getJsDocTags(checker) ?? []).find(
+                    (tag) => tag.name === "internal",
+                ) !== undefined
+            )
+                continue;
+
             // CHECK NODE IS A FORMAL PROPERTY
             const [node, type] = (() => {
-                const node = (prop.declarations ?? [])[0] as
+                const node = (prop.getDeclarations() ?? [])[0] as
                     | ts.PropertyDeclaration
                     | undefined;
                 const type: ts.Type | undefined = node
@@ -91,34 +93,25 @@ export const emplace_metadata_object =
                     : "getTypeOfPropertyOfType" in checker
                     ? (checker as any).getTypeOfPropertyOfType(
                           parent,
-                          prop.escapedName.toString(),
+                          prop.name,
                       )
                     : 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)(
+            const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+            const value: Metadata = explore_metadata(checker)(options)(
                 collection,
-            )(false)(type);
+            )(type, false);
 
             // INSERT WITH REQUIRED CONFIGURATION
             if (node?.questionToken) {
                 Writable(value).required = false;
                 Writable(value).optional = true;
             }
-            insert(key)(value)(
-                () => `${obj.name}.${prop.escapedName.toString()}`,
-            )(prop);
+            insert(key)(value)(() => `${obj.name}.${prop.name}`)(prop);
         }
 
         //----
@@ -127,9 +120,7 @@ export const emplace_metadata_object =
         for (const index of checker.getIndexInfosOfType(parent)) {
             // GET EXACT TYPE
             const analyzer = (type: ts.Type) =>
-                explore_metadata({ tsc, checker })(options)(collection)(false)(
-                    type,
-                );
+                explore_metadata(checker)(options)(collection)(type, false);
             const key: Metadata = analyzer(index.keyType);
             const value: Metadata = analyzer(index.type);
 
@@ -141,12 +132,11 @@ export const emplace_metadata_object =
                 (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);
+const isProperty = (node: ts.Declaration) =>
+    ts.isPropertyDeclaration(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isPropertySignature(node) ||
+    ts.isTypeLiteralNode(node);

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

@@ -0,0 +1,50 @@
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataTuple } from "../../../metadata/MetadataTuple";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_tuple =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+        // CHECK EXISTENCE
+        const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
+        ArrayUtil.add(tuple.nullables, nullable);
+        if (newbie === false) return tuple;
+
+        // CONSTRUCT ELEMENT TYPES
+        const flagList: readonly ts.ElementFlags[] =
+            type.elementFlags ??
+            (type.target as ts.TupleType)?.elementFlags ??
+            [];
+        const elements: Metadata[] = checker
+            .getTypeArguments(type as ts.TypeReference)
+            .map((elem, i) => {
+                const child: Metadata = explore_metadata(checker)(options)(
+                    collection,
+                )(elem, false, false);
+
+                // CHECK OPTIONAL
+                const flag: ts.ElementFlags | undefined = flagList[i];
+                if (flag === ts.ElementFlags.Optional)
+                    Writable(child).optional = true;
+
+                // REST TYPE
+                if (flag !== ts.ElementFlags.Rest) return child;
+                const wrapper: Metadata = Metadata.initialize();
+                Writable(wrapper).rest = child;
+                return wrapper;
+            });
+        closure(elements);
+
+        return tuple;
+    };

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

@@ -1,9 +1,6 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProject } from "../../../transformers/IProject";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -12,50 +9,29 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const explore_metadata =
-    (project: IProject.IModule) =>
+    (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (parentResolved: boolean) =>
-    (type: ts.Type | null): Metadata => {
+    (
+        type: ts.Type | null,
+        parentResolved: boolean,
+        aliased: boolean = false,
+    ): 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);
-        }
+        const out = (meta: Metadata) => {
+            if (options.validate) options.validate(meta);
+            return meta;
+        };
+        if (type === null) return out(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;
-            });
+        // ITERATE TYPESCRIPT TYPES
+        iterate_metadata(checker)(options)(collection)(
+            meta,
+            type,
+            parentResolved,
+            aliased,
+        );
 
         // EMEND ATOMICS
         for (const type of meta.atomics) {
@@ -86,8 +62,5 @@ export const explore_metadata =
             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;
+        return out(meta);
     };