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

package/src/schemas/IJsonComponents.ts

@@ -3,16 +3,23 @@ import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
 import { IJsonSchema } from "./IJsonSchema";
 
 export interface IJsonComponents {
-    schemas: Record<string, IJsonComponents.IObject>;
+    objects?: Record<string, IJsonComponents.IObject>;
+    aliases?: Record<string, IJsonComponents.IAlias>;
+    arrays?: Record<string, IJsonComponents.IArray>;
+    tuples?: Record<string, IJsonComponents.ITuple | IJsonComponents.IArray>;
 }
 export namespace IJsonComponents {
+    export interface IArray extends IJsonSchema.IArray {
+        $id?: string;
+        $recursiveAnchor?: true;
+    }
+    export interface ITuple extends IJsonSchema.ITuple {
+        $id?: string;
+        $recursiveAnchor?: true;
+    }
     export interface IObject {
-        /**
-         * Used only when ajv mode.
-         */
         $id?: string;
         $recursiveAnchor?: boolean;
-
         type: "object";
 
         /**
@@ -30,4 +37,9 @@ export namespace IJsonComponents {
         "x-typia-patternProperties"?: Record<string, IJsonSchema>;
         "x-typia-additionalProperties"?: IJsonSchema;
     }
+
+    export type IAlias = IJsonSchema & {
+        $id?: string;
+        $recursiveAnchor?: boolean;
+    };
 }

package/src/schemas/IJsonSchema.ts

@@ -95,6 +95,7 @@ export namespace IJsonSchema {
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];
+        "x-typia-rest": boolean;
     }
     export interface IReference extends IAttribute {
         $ref: string;
@@ -129,6 +130,5 @@ export namespace IJsonSchema {
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
         "x-typia-optional"?: boolean;
-        "x-typia-rest"?: boolean;
     }
 }

package/src/transform.ts

@@ -1,39 +1,17 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { FileTransformer } from "./transformers/FileTransformer";
 import { ITransformOptions } from "./transformers/ITransformOptions";
 
-const regular: ts.CustomTransformersModuleFactory = ({ typescript }) => ({
-    create: (info) => ({
-        before: [
-            (context) => (file) =>
-                FileTransformer.transform({
-                    tsc: typescript,
-                    program: info.program,
-                    compilerOptions: info.program.getCompilerOptions(),
-                    checker: info.program.getTypeChecker(),
-                    printer: typescript.createPrinter(),
-                    options: info.config ?? {},
-                })(context)(file),
-        ],
-    }),
-});
-
-const patch = (
+export const transform = (
     program: ts.Program,
     options?: ITransformOptions,
-): ts.TransformerFactory<ts.SourceFile> => {
-    const tsc = require("ts");
-    return FileTransformer.transform({
-        tsc,
+): ts.TransformerFactory<ts.SourceFile> =>
+    FileTransformer.transform({
         program,
         compilerOptions: program.getCompilerOptions(),
         checker: program.getTypeChecker(),
-        printer: tsc.createPrinter(),
+        printer: ts.createPrinter(),
         options: options || {},
     });
-};
-
-const transform = (x: any, y?: any) =>
-    x.typescript ? regular(x) : patch(x, y);
-export = transform as typeof regular | typeof patch;
+export default transform;

package/src/transformers/CallExpressionTransformer.ts

@@ -1,7 +1,5 @@
 import path from "path";
-import type ts from "typescript/lib/tsclibrary";
-
-import { TsNodeUtil } from "../utils/TsNodeUtil";
+import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
@@ -60,9 +58,8 @@ export namespace CallExpressionTransformer {
 
             // FILE PATH
             const file: string = path.resolve(
-                TsNodeUtil.getSourceFile(project.tsc)(declaration).fileName,
+                declaration.getSourceFile().fileName,
             );
-
             if (
                 file.indexOf(LIB_PATH) === -1 &&
                 file !== SRC_PATH &&
@@ -74,14 +71,15 @@ export namespace CallExpressionTransformer {
             // TRANSFORMATION
             //----
             // FUNCTION NAME
-            const { escapedName } =
+            const { name } =
                 project.checker.getTypeAtLocation(declaration).symbol;
 
             // FIND TRANSFORMER
-            const functor: (() => Task) | undefined =
-                FUNCTORS[escapedName.toString()];
+            const functor: (() => Task) | undefined = FUNCTORS[name];
             if (functor === undefined) return expression;
 
+            // console.log(expression.getSourceFile().fileName);
+
             // RETURNS WITH TRANSFORMATION
             return functor()(project)(expression.expression)(expression);
         };
@@ -94,9 +92,7 @@ type Task = (
 ) => (expression: ts.CallExpression) => ts.Expression;
 
 const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
-const SRC_PATH = path.resolve(
-    path.join(__dirname, "..", "..", "src", "module.ts"),
-);
+const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
 const CLI_PATH = path.resolve(
     path.join(__dirname, "..", "..", "..", "src", "module.ts"),
 );

package/src/transformers/FileTransformer.ts

@@ -1,6 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { TsNodeUtil } from "../utils/TsNodeUtil";
+import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { NodeTransformer } from "./NodeTransformer";
@@ -9,20 +7,20 @@ export namespace FileTransformer {
     export const transform =
         (project: IProject) =>
         (context: ts.TransformationContext) =>
-        (file: ts.SourceFile): ts.SourceFile =>
-            file.isDeclarationFile
-                ? file
-                : project.tsc.visitEachChild(
-                      file,
-                      (node) => iterate_node(project)(context)(node),
-                      context,
-                  );
+        (file: ts.SourceFile): ts.SourceFile => {
+            if (file.isDeclarationFile) return file;
+            return ts.visitEachChild(
+                file,
+                (node) => iterate_node(project)(context)(node),
+                context,
+            );
+        };
 
     const iterate_node =
         (project: IProject) =>
         (context: ts.TransformationContext) =>
         (node: ts.Node): ts.Node =>
-            project.tsc.visitEachChild(
+            ts.visitEachChild(
                 try_transform_node(project)(node),
                 (child) => iterate_node(project)(context)(child),
                 context,
@@ -36,11 +34,10 @@ export namespace FileTransformer {
             } catch (exp) {
                 if (!(exp instanceof Error)) throw exp;
 
-                const file: ts.SourceFile = TsNodeUtil.getSourceFile(
-                    project.tsc,
-                )(node);
-                const { line, character } =
-                    project.tsc.getLineAndCharacterOfPosition(file, node.pos);
+                const file: ts.SourceFile = node.getSourceFile();
+                const { line, character } = file.getLineAndCharacterOfPosition(
+                    node.pos,
+                );
                 exp.message += ` - ${file.fileName}:${line + 1}:${
                     character + 1
                 }`;

package/src/transformers/IProject.ts

@@ -1,18 +1,11 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ITransformOptions } from "./ITransformOptions";
 
 export interface IProject {
-    tsc: typeof ts;
     program: ts.Program;
     compilerOptions: ts.CompilerOptions;
     checker: ts.TypeChecker;
     printer: ts.Printer;
     options: ITransformOptions;
 }
-export namespace IProject {
-    export interface IModule {
-        tsc: typeof ts;
-        checker: ts.TypeChecker;
-    }
-}

package/src/transformers/ImportTransformer.ts

@@ -1,19 +1,15 @@
 import path from "path";
-import type ts from "typescript/lib/tsclibrary";
-
-import { TsNodeUtil } from "../utils/TsNodeUtil";
+import ts from "typescript";
 
 export namespace ImportTransformer {
     export const transform =
-        (tsc: typeof ts) =>
         (from: string) =>
         (to: string) =>
         (context: ts.TransformationContext) =>
         (file: ts.SourceFile) =>
-            transform_file(tsc)(from)(to)(context)(file);
+            transform_file(from)(to)(context)(file);
 
     const transform_file =
-        (tsc: typeof ts) =>
         (top: string) =>
         (to: string) =>
         (context: ts.TransformationContext) =>
@@ -21,26 +17,22 @@ export namespace ImportTransformer {
             if (file.isDeclarationFile) return file;
 
             const from: string = get_directory_path(
-                path.resolve(TsNodeUtil.getSourceFile(tsc)(file).fileName),
+                path.resolve(file.getSourceFile().fileName),
             );
             to = from.replace(top, to);
 
-            return tsc.visitEachChild(
+            return ts.visitEachChild(
                 file,
-                (node) => transform_node(tsc)(top)(from)(to)(node),
+                (node) => transform_node(top)(from)(to)(node),
                 context,
             );
         };
 
     const transform_node =
-        (tsc: typeof ts) =>
-        (top: string) =>
-        (from: string) =>
-        (to: string) =>
-        (node: ts.Node) => {
+        (top: string) => (from: string) => (to: string) => (node: ts.Node) => {
             if (
-                !tsc.isImportDeclaration(node) ||
-                !tsc.isStringLiteral(node.moduleSpecifier)
+                !ts.isImportDeclaration(node) ||
+                !ts.isStringLiteral(node.moduleSpecifier)
             )
                 return node;
 
@@ -58,10 +50,10 @@ export namespace ImportTransformer {
                 return simple[0] === "." ? simple : `./${simple}`;
             })();
 
-            return tsc.factory.createImportDeclaration(
+            return ts.factory.createImportDeclaration(
                 undefined,
                 node.importClause,
-                tsc.factory.createStringLiteral(replaced),
+                ts.factory.createStringLiteral(replaced),
                 node.assertClause,
             );
         };

package/src/transformers/NodeTransformer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { CallExpressionTransformer } from "./CallExpressionTransformer";
 import { IProject } from "./IProject";
@@ -7,7 +7,7 @@ export namespace NodeTransformer {
     export const transform =
         (project: IProject) =>
         (expression: ts.Node): ts.Node =>
-            project.tsc.isCallExpression(expression)
+            ts.isCallExpression(expression)
                 ? CallExpressionTransformer.transform(project)(expression)
                 : expression;
 }

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
@@ -9,13 +9,11 @@ import { IJsonApplication } from "../../../schemas/IJsonApplication";
 
 import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
 
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
 import { IProject } from "../../IProject";
 
 export namespace ApplicationTransformer {
     export const transform =
-        (p: IProject) =>
+        ({ checker }: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new Error(NO_GENERIC_ARGUMENT);
@@ -25,22 +23,20 @@ export namespace ApplicationTransformer {
             //----
             // VALIDATE TUPLE ARGUMENTS
             const top: ts.Node = expression.typeArguments[0]!;
-            if (!p.tsc.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !p.tsc.isTypeNode(child)))
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
                 return expression;
 
             // GET TYPES
-            const typeList: ts.Type[] = top.elements.map((child) =>
-                p.checker.getTypeFromTypeNode(child as ts.TypeNode),
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
-            if (
-                typeList.some((type) => TsTypeUtil.isTypeParameter(p.tsc)(type))
-            )
+            if (types.some((t) => t.isTypeParameter()))
                 throw new Error(GENERIC_ARGUMENT);
 
             // ADDITIONAL PARAMETERS
             const purpose: "swagger" | "ajv" = get_parameter(
-                p,
+                checker,
                 "Purpose",
                 expression.typeArguments[1],
                 (str) => str === "swagger" || str === "ajv",
@@ -54,10 +50,11 @@ export namespace ApplicationTransformer {
             const collection: MetadataCollection = new MetadataCollection({
                 replace: MetadataCollection.replace,
             });
-            const metadatas: Array<Metadata> = typeList.map((type) =>
-                MetadataFactory.analyze(p)({
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
                     resolve: true,
                     constant: true,
+                    absorb: false,
                     validate: (meta) => {
                         if (meta.atomics.find((str) => str === "bigint"))
                             throw new Error(NO_BIGIT);
@@ -71,11 +68,11 @@ export namespace ApplicationTransformer {
             })(metadatas);
 
             // RETURNS WITH LITERAL EXPRESSION
-            return LiteralFactory.generate(p.tsc)(app);
+            return LiteralFactory.generate(app);
         };
 
     const get_parameter = <T extends string>(
-        p: IProject.IModule,
+        checker: ts.TypeChecker,
         name: string,
         node: ts.TypeNode | undefined,
         predicator: (value: string) => boolean,
@@ -84,8 +81,8 @@ export namespace ApplicationTransformer {
         if (!node) return defaulter();
 
         // CHECK LITERAL TYPE
-        const type: ts.Type = p.checker.getTypeFromTypeNode(node);
-        if (!TsTypeUtil.isLiteral(p.tsc)(type))
+        const type: ts.Type = checker.getTypeFromTypeNode(node);
+        if (!type.isLiteral())
             throw new Error(
                 `Error on typia.application(): generic argument "${name}" must be constant.`,
             );

package/src/transformers/features/miscellaneous/CreateRandomTransformer.ts

@@ -1,15 +1,12 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
 
-import { TsNodeUtil } from "../../../utils/TsNodeUtil";
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
 import { IProject } from "../../IProject";
 
 export namespace CreateRandomTransformer {
     export const transform =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
@@ -17,22 +14,21 @@ export namespace CreateRandomTransformer {
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
-                throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
             return RandomProgrammer.write({
-                ...p,
+                ...project,
                 options: {
-                    ...p.options,
+                    ...project.options,
                     functional: false,
                     numeric: false,
                 },
             })(modulo)(expression.arguments?.[0])(
                 type,
-                TsNodeUtil.getFullText(p.tsc)(node).trim(),
+                node.getFullText().trim(),
             );
         };
 }

package/src/transformers/features/miscellaneous/LiteralsTransformer.ts

@@ -1,27 +1,24 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
 
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
 import { IProject } from "../../IProject";
 
 export namespace LiteralsTransformer {
     export const transform =
-        (p: IProject) =>
+        (project: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
-                throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
-            return LiteralsProgrammer.write(p)(type);
+            return LiteralsProgrammer.write(project)(type);
         };
 }
 

package/src/transformers/features/miscellaneous/MetadataTransformer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
@@ -7,47 +7,44 @@ import { MetadataFactory } from "../../../factories/MetadataFactory";
 import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
 import { Metadata } from "../../../metadata/Metadata";
 
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
 import { IProject } from "../../IProject";
 
 export namespace MetadataTransformer {
     export const transform =
-        (p: IProject) =>
+        ({ checker }: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new Error(NO_GENERIC_ARGUMENT);
 
             // VALIDATE TUPLE ARGUMENTS
             const top: ts.Node = expression.typeArguments[0]!;
-            if (!p.tsc.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !p.tsc.isTypeNode(child)))
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
                 return expression;
 
             // GET TYPES
-            const typeList: ts.Type[] = top.elements.map((child) =>
-                p.checker.getTypeFromTypeNode(child as ts.TypeNode),
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
-            if (
-                typeList.some((type) => TsTypeUtil.isTypeParameter(p.tsc)(type))
-            )
+            if (types.some((t) => t.isTypeParameter()))
                 throw new Error(GENERIC_ARGUMENT);
 
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = typeList.map((type) =>
-                MetadataFactory.analyze(p)({
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
                     resolve: false,
                     constant: true,
+                    absorb: true,
                 })(collection)(type),
             );
 
             // CONVERT TO PRIMITIVE TYPE
             const app: IMetadataApplication = {
                 metadatas: metadatas.map((metadata) => metadata.toJSON()),
-                collection: collection.objects().map((obj) => obj.toJSON()),
+                collection: collection.toJSON(),
             };
-            return LiteralFactory.generate(p.tsc)(app);
+            return LiteralFactory.generate(app);
         };
 }
 

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -1,15 +1,12 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
 
-import { TsNodeUtil } from "../../../utils/TsNodeUtil";
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
 import { IProject } from "../../IProject";
 
 export namespace RandomTransformer {
     export const transform =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
@@ -17,21 +14,20 @@ export namespace RandomTransformer {
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
-                throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
-            return p.tsc.factory.createCallExpression(
+            return ts.factory.createCallExpression(
                 RandomProgrammer.write({
-                    ...p,
+                    ...project,
                     options: {
-                        ...p.options,
+                        ...project.options,
                         functional: false,
                         numeric: false,
                     },
-                })(modulo)()(type, TsNodeUtil.getFullText(p.tsc)(node).trim()),
+                })(modulo)()(type, node.getFullText().trim()),
                 undefined,
                 expression.arguments.length
                     ? [expression.arguments[0]!]