typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/factories/MetadataFactory.ts

@@ -1,8 +1,10 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../metadata/Metadata";
 import { explore_metadata } from "./internal/metadata/explore_metadata";
 
+import { IProject } from "../transformers/IProject";
+
 import { MetadataCollection } from "./MetadataCollection";
 
 export namespace MetadataFactory {
@@ -13,14 +15,13 @@ export namespace MetadataFactory {
     }
 
     export const analyze =
-        (checker: ts.TypeChecker) =>
+        (project: IProject.IModule) =>
         (options: IOptions) =>
         (collection: MetadataCollection) =>
         (type: ts.Type | null): Metadata => {
             // CONSTRUCT SCHEMA WITH OBJECTS
-            const metadata: Metadata = explore_metadata(checker)(options)(
-                collection,
-            )(type, false);
+            const metadata: Metadata =
+                explore_metadata(project)(options)(collection)(false)(type);
 
             // FIND RECURSIVE OBJECTS
             for (const object of collection.objects())
@@ -49,14 +50,4 @@ export namespace MetadataFactory {
                 meta.maps.some((map) => isRecursive(name)(map.value))
             );
         };
-
-    /**
-     * @deprecated Use `analyze` function instead
-     */
-    export const generate = (
-        checker: ts.TypeChecker,
-        collection: MetadataCollection,
-        type: ts.Type,
-        options: IOptions,
-    ) => analyze(checker)(options)(collection)(type);
 }

package/src/factories/MetadataTagFactory.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import { JSDocTagInfo } from "typescript";
 
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
@@ -6,7 +6,7 @@ import { Metadata } from "../metadata/Metadata";
 export namespace MetadataTagFactory {
     export const generate =
         (metadata: Metadata) =>
-        (tagList: ts.JSDocTagInfo[]) =>
+        (tagList: JSDocTagInfo[]) =>
         (identifier: () => string): IMetadataTag[] => {
             const output: IMetadataTag[] = [];
             for (const tag of tagList) {
@@ -24,13 +24,13 @@ export namespace MetadataTagFactory {
     const parse = (
         identifier: () => string,
         metadata: Metadata,
-        tag: ts.JSDocTagInfo,
+        tag: JSDocTagInfo,
         output: IMetadataTag[],
     ): IMetadataTag | null => {
         const closure = _PARSER[tag.name];
         if (closure === undefined) return null;
 
-        const text = (tag.text || [])[0]?.text;
+        const text: string | undefined = tag.text?.[0]?.text;
         if (text === undefined)
             throw new Error(`${LABEL}: no tag value on ${identifier()}`);
 
@@ -83,13 +83,11 @@ export namespace MetadataTagFactory {
         /* -----------------------------------------------------------
             NUMBER
         ----------------------------------------------------------- */
-        type: (identifier, metadata, text, output) => {
-            validate(identifier, metadata, output, "type", "number", []);
-            if (text !== "int" && text !== "uint")
-                throw new Error(
-                    `${LABEL}: invalid type tag on "${identifier()}".`,
-                );
-            return { kind: "type", value: text };
+        type: (_identifier, metadata, text, _output) => {
+            return has_atomic(metadata)("number") &&
+                (text === "int" || text === "uint")
+                ? { kind: "type", value: text }
+                : null;
         },
         minimum: (identifier, metadata, text, output) => {
             validate(identifier, metadata, output, "minimum", "number", [

package/src/factories/StatementFactory.ts

@@ -1,24 +1,20 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 export namespace StatementFactory {
-    export const constant = (name: string, initializer?: ts.Expression) =>
-        ts.factory.createVariableStatement(
-            undefined,
-            ts.factory.createVariableDeclarationList(
-                [
-                    ts.factory.createVariableDeclaration(
-                        name,
-                        undefined,
-                        undefined,
-                        initializer,
-                    ),
-                ],
-                ts.NodeFlags.Const,
-            ),
-        );
-
-    export const transpile = (script: string) =>
-        ts.factory.createExpressionStatement(
-            ts.factory.createIdentifier(ts.transpile(script)),
-        );
+    export const constant =
+        (tsc: typeof ts) => (name: string, initializer?: ts.Expression) =>
+            tsc.factory.createVariableStatement(
+                undefined,
+                tsc.factory.createVariableDeclarationList(
+                    [
+                        tsc.factory.createVariableDeclaration(
+                            name,
+                            undefined,
+                            undefined,
+                            initializer,
+                        ),
+                    ],
+                    tsc.NodeFlags.Const,
+                ),
+            );
 }

package/src/factories/TemplateFactory.ts

@@ -1,46 +1,52 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 export namespace TemplateFactory {
-    export const generate = (expressions: ts.Expression[]): ts.Expression => {
-        if (expressions.every((exp) => ts.isStringLiteral(exp)))
-            return ts.factory.createStringLiteral(
-                (expressions as ts.StringLiteral[])
-                    .map((str) => str.text)
-                    .join(""),
+    export const generate =
+        (tsc: typeof ts) =>
+        (expressions: ts.Expression[]): ts.Expression => {
+            if (expressions.every((exp) => tsc.isStringLiteral(exp)))
+                return tsc.factory.createStringLiteral(
+                    (expressions as ts.StringLiteral[])
+                        .map((str) => str.text)
+                        .join(""),
+                );
+
+            const it: IIterator = {
+                value: "",
+                index: 0,
+            };
+            gather(tsc)(expressions)(it);
+
+            const head: ts.TemplateHead = tsc.factory.createTemplateHead(
+                it.value,
             );
+            const spans: ts.TemplateSpan[] = [];
 
-        const it: IIterator = {
-            value: "",
-            index: 0,
+            while (true) {
+                const elem: ts.Expression = expressions[it.index++]!;
+                gather(tsc)(expressions)(it);
+
+                const broken: boolean = it.index === expressions.length;
+                spans.push(
+                    tsc.factory.createTemplateSpan(
+                        elem,
+                        broken
+                            ? tsc.factory.createTemplateTail(it.value)
+                            : tsc.factory.createTemplateMiddle(it.value),
+                    ),
+                );
+                if (broken === true) break;
+            }
+            return tsc.factory.createTemplateExpression(head, spans);
         };
-        gather(expressions)(it);
-
-        const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
-        const spans: ts.TemplateSpan[] = [];
-
-        while (true) {
-            const elem: ts.Expression = expressions[it.index++]!;
-            gather(expressions)(it);
-
-            const broken: boolean = it.index === expressions.length;
-            spans.push(
-                ts.factory.createTemplateSpan(
-                    elem,
-                    broken
-                        ? ts.factory.createTemplateTail(it.value)
-                        : ts.factory.createTemplateMiddle(it.value),
-                ),
-            );
-            if (broken === true) break;
-        }
-        return ts.factory.createTemplateExpression(head, spans);
-    };
 
     const gather =
+        (tsc: typeof ts) =>
         (expressions: ts.Expression[]) =>
         (it: IIterator): void => {
             const found: number = expressions.findIndex(
-                (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
+                (elem, index) =>
+                    index >= it.index && !tsc.isStringLiteral(elem),
             );
 
             const last: number = found !== -1 ? found : expressions.length;

package/src/factories/TypeFactory.ts

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

package/src/factories/ValueFactory.ts

@@ -1,12 +1,15 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 export namespace ValueFactory {
-    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);
+    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);
 }

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

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