typia 3.5.0-dev.20221219 → 3.5.0-dev.20221222

package/src/transform.ts

@@ -1,20 +1,20 @@
-import ts from "typescript";
-
-import { FileTransformer } from "./transformers/FileTransformer";
-import { IProject } from "./transformers/IProject";
-import { ITransformOptions } from "./transformers/ITransformOptions";
-
-export default function transform(
-    program: ts.Program,
-    options?: ITransformOptions,
-): ts.TransformerFactory<ts.SourceFile> {
-    const project: IProject = {
-        program,
-        compilerOptions: program.getCompilerOptions(),
-        checker: program.getTypeChecker(),
-        printer: ts.createPrinter(),
-        options: options || {},
-    };
-    return (context) => (file) =>
-        FileTransformer.transform(project, context, file);
-}
+import ts from "typescript";
+
+import { FileTransformer } from "./transformers/FileTransformer";
+import { IProject } from "./transformers/IProject";
+import { ITransformOptions } from "./transformers/ITransformOptions";
+
+export default function transform(
+    program: ts.Program,
+    options?: ITransformOptions,
+): ts.TransformerFactory<ts.SourceFile> {
+    const project: IProject = {
+        program,
+        compilerOptions: program.getCompilerOptions(),
+        checker: program.getTypeChecker(),
+        printer: ts.createPrinter(),
+        options: options || {},
+    };
+    return (context) => (file) =>
+        FileTransformer.transform(project, context, file);
+}

package/src/transformers/ExpressionWithArgumentTransformer.ts

@@ -1,66 +1,66 @@
-// import path from "path";
-// import ts from "typescript";
-// import { AssertProgrammer } from "../programmers/AssertProgrammer";
-// import { IsProgrammer } from "../programmers/IsProgrammer";
-// import { StringifyProgrammer } from "../programmers/StringifyProgrammer";
-// import { IProject } from "../structures/IProject";
-
-// export namespace ExpressionWithArgumentTransformer {
-//     export function transform(
-//         project: IProject,
-//         expression: ts.ExpressionWithTypeArguments,
-//     ): ts.Expression {
-//         //----
-//         // VALIDATIONS
-//         //----
-//         // SYMBOL DECLARATION
-//         const symbol: ts.Symbol | undefined =
-//             project.checker.getSymbolAtLocation(expression.expression);
-//         const declaration: ts.Declaration | undefined = symbol?.declarations
-//             ? symbol.declarations[0]
-//             : undefined;
-//         if (!declaration) return expression;
-
-//         // FILE PATH
-//         const file: string = path.resolve(declaration.getSourceFile().fileName);
-//         if (file !== LIB_PATH && file !== SRC_PATH) return expression;
-
-//         // ARGUMENTS
-//         if (expression.typeArguments?.length !== 1) return expression;
-
-//         //----
-//         // TRANSFORMATION
-//         //----
-//         // GET MODULO AND TYPE
-//         const modulo: ts.LeftHandSideExpression = expression.expression;
-//         const type: ts.Type = project.checker.getTypeFromTypeNode(
-//             expression.typeArguments[0]!,
-//         );
-
-//         // FUNCTION NAME
-//         const { name } = project.checker.getTypeAtLocation(declaration).symbol;
-
-//         // FIND TRANSFORMER
-//         const functor: (() => Task) | undefined = FUNCTORS[name];
-//         if (functor === undefined) return expression;
-
-//         // RETURNS WITH TRANSFORMATION
-//         return functor()(project, modulo, type);
-//     }
-// }
-
-// type Task = (
-//     project: IProject,
-//     modulo: ts.LeftHandSideExpression,
-//     type: ts.Type,
-// ) => ts.ArrowFunction;
-
-// const LIB_PATH = path.resolve(path.join(__dirname, "..", "module.d.ts"));
-// const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
-
-// const FUNCTORS: Record<string, () => Task> = {
-//     assert: () => AssertProgrammer.generate,
-//     is: () => (project, _modulo, type) => IsProgrammer.generate(project, type),
-//     stringify: () => (project, modulo, type) =>
-//         StringifyProgrammer.generate(modulo)(project, type),
-// };
+// import path from "path";
+// import ts from "typescript";
+// import { AssertProgrammer } from "../programmers/AssertProgrammer";
+// import { IsProgrammer } from "../programmers/IsProgrammer";
+// import { StringifyProgrammer } from "../programmers/StringifyProgrammer";
+// import { IProject } from "../structures/IProject";
+
+// export namespace ExpressionWithArgumentTransformer {
+//     export function transform(
+//         project: IProject,
+//         expression: ts.ExpressionWithTypeArguments,
+//     ): ts.Expression {
+//         //----
+//         // VALIDATIONS
+//         //----
+//         // SYMBOL DECLARATION
+//         const symbol: ts.Symbol | undefined =
+//             project.checker.getSymbolAtLocation(expression.expression);
+//         const declaration: ts.Declaration | undefined = symbol?.declarations
+//             ? symbol.declarations[0]
+//             : undefined;
+//         if (!declaration) return expression;
+
+//         // FILE PATH
+//         const file: string = path.resolve(declaration.getSourceFile().fileName);
+//         if (file !== LIB_PATH && file !== SRC_PATH) return expression;
+
+//         // ARGUMENTS
+//         if (expression.typeArguments?.length !== 1) return expression;
+
+//         //----
+//         // TRANSFORMATION
+//         //----
+//         // GET MODULO AND TYPE
+//         const modulo: ts.LeftHandSideExpression = expression.expression;
+//         const type: ts.Type = project.checker.getTypeFromTypeNode(
+//             expression.typeArguments[0]!,
+//         );
+
+//         // FUNCTION NAME
+//         const { name } = project.checker.getTypeAtLocation(declaration).symbol;
+
+//         // FIND TRANSFORMER
+//         const functor: (() => Task) | undefined = FUNCTORS[name];
+//         if (functor === undefined) return expression;
+
+//         // RETURNS WITH TRANSFORMATION
+//         return functor()(project, modulo, type);
+//     }
+// }
+
+// type Task = (
+//     project: IProject,
+//     modulo: ts.LeftHandSideExpression,
+//     type: ts.Type,
+// ) => ts.ArrowFunction;
+
+// const LIB_PATH = path.resolve(path.join(__dirname, "..", "module.d.ts"));
+// const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+
+// const FUNCTORS: Record<string, () => Task> = {
+//     assert: () => AssertProgrammer.generate,
+//     is: () => (project, _modulo, type) => IsProgrammer.generate(project, type),
+//     stringify: () => (project, modulo, type) =>
+//         StringifyProgrammer.generate(modulo)(project, type),
+// };

package/src/transformers/FileTransformer.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-import { IProject } from "./IProject";
-import { NodeTransformer } from "./NodeTransformer";
-
-export namespace FileTransformer {
-    export function transform(
-        project: IProject,
-        context: ts.TransformationContext,
-        file: ts.SourceFile,
-    ): ts.SourceFile {
-        // DO NOT TRANSFORM D.TS FILE
-        if (file.isDeclarationFile) return file;
-
-        // ITERATE NODES
-        return ts.visitEachChild(
-            file,
-            (node) => iterate_node(project, context, node),
-            context,
-        );
-    }
-
-    function iterate_node(
-        project: IProject,
-        context: ts.TransformationContext,
-        node: ts.Node,
-    ): ts.Node {
-        return ts.visitEachChild(
-            try_transform_node(project, node),
-            (child) => iterate_node(project, context, child),
-            context,
-        );
-    }
-
-    function try_transform_node(project: IProject, node: ts.Node): ts.Node {
-        try {
-            return NodeTransformer.transform(project, node);
-        } catch (exp) {
-            if (!(exp instanceof Error)) throw exp;
-
-            const file: ts.SourceFile = node.getSourceFile();
-            const { line, character } = file.getLineAndCharacterOfPosition(
-                node.pos,
-            );
-            exp.message += ` - ${file.fileName}:${line + 1}:${character + 1}`;
-            throw exp;
-        }
-    }
-}
+import ts from "typescript";
+
+import { IProject } from "./IProject";
+import { NodeTransformer } from "./NodeTransformer";
+
+export namespace FileTransformer {
+    export function transform(
+        project: IProject,
+        context: ts.TransformationContext,
+        file: ts.SourceFile,
+    ): ts.SourceFile {
+        // DO NOT TRANSFORM D.TS FILE
+        if (file.isDeclarationFile) return file;
+
+        // ITERATE NODES
+        return ts.visitEachChild(
+            file,
+            (node) => iterate_node(project, context, node),
+            context,
+        );
+    }
+
+    function iterate_node(
+        project: IProject,
+        context: ts.TransformationContext,
+        node: ts.Node,
+    ): ts.Node {
+        return ts.visitEachChild(
+            try_transform_node(project, node),
+            (child) => iterate_node(project, context, child),
+            context,
+        );
+    }
+
+    function try_transform_node(project: IProject, node: ts.Node): ts.Node {
+        try {
+            return NodeTransformer.transform(project, node);
+        } catch (exp) {
+            if (!(exp instanceof Error)) throw exp;
+
+            const file: ts.SourceFile = node.getSourceFile();
+            const { line, character } = file.getLineAndCharacterOfPosition(
+                node.pos,
+            );
+            exp.message += ` - ${file.fileName}:${line + 1}:${character + 1}`;
+            throw exp;
+        }
+    }
+}

package/src/transformers/IProject.ts

@@ -1,11 +1,11 @@
-import ts from "typescript";
-
-import { ITransformOptions } from "./ITransformOptions";
-
-export interface IProject {
-    program: ts.Program;
-    compilerOptions: ts.CompilerOptions;
-    checker: ts.TypeChecker;
-    printer: ts.Printer;
-    options: ITransformOptions;
-}
+import ts from "typescript";
+
+import { ITransformOptions } from "./ITransformOptions";
+
+export interface IProject {
+    program: ts.Program;
+    compilerOptions: ts.CompilerOptions;
+    checker: ts.TypeChecker;
+    printer: ts.Printer;
+    options: ITransformOptions;
+}

package/src/transformers/ITransformOptions.ts

@@ -1,4 +1,47 @@
 export interface ITransformOptions {
-    functional?: boolean | "checker" | "stringify";
-    numeric?: boolean | "checker" | "stringify";
+    /**
+     * Whether to validate finite number or not.
+     *
+     * If configured true, number typed values would be validated by Number.isNaN().
+     *
+     * However, whatever you configure, it would be ignored when marshaling or parsing.
+     *
+     *   - when marshaling, always be true
+     *     - assertStringify()
+     *     - validateEncode()
+     *   - when parsing, always be false
+     *     - assertParse()
+     *     - isDecode()
+     *
+     * @default false
+     */
+    finite?: boolean;
+
+    /**
+     * Whether to validate finite number or not.
+     *
+     * If configured true, number typed values would be validated by Number.isFinite().
+     *
+     * However, whatever you configure, it can be ignored in below case.
+     *
+     *   - when `finite` option is true, this option would be ignored
+     *   - when marshaling, always be true
+     *     - assertStringify()
+     *     - validateEncode()
+     *   - when parsing, always be false
+     *     - assertParse()
+     *     - isDecode()
+     *
+     * @default false
+     */
+    numeric?: boolean;
+
+    /**
+     * Whether to validate functional type or not.
+     *
+     * However, whatever you configure, it becomes false when marshaling or parsing.
+     *
+     * @default false
+     */
+    functional?: boolean;
 }

package/src/transformers/NodeTransformer.ts

@@ -1,19 +1,19 @@
-import ts from "typescript";
-
-import { CallExpressionTransformer } from "./CallExpressionTransformer";
-import { IProject } from "./IProject";
-
-// import { ExpressionWithArgumentTransformer } from "./ExpressionWithArgumentTransformer";
-
-export namespace NodeTransformer {
-    export function transform(project: IProject, expression: ts.Node): ts.Node {
-        if (ts.isCallExpression(expression))
-            return CallExpressionTransformer.transform(project, expression);
-        // else if (ts.isExpressionWithTypeArguments(expression))
-        //     return ExpressionWithArgumentTransformer.transform(
-        //         project,
-        //         expression,
-        //     );
-        return expression;
-    }
-}
+import ts from "typescript";
+
+import { CallExpressionTransformer } from "./CallExpressionTransformer";
+import { IProject } from "./IProject";
+
+// import { ExpressionWithArgumentTransformer } from "./ExpressionWithArgumentTransformer";
+
+export namespace NodeTransformer {
+    export function transform(project: IProject, expression: ts.Node): ts.Node {
+        if (ts.isCallExpression(expression))
+            return CallExpressionTransformer.transform(project, expression);
+        // else if (ts.isExpressionWithTypeArguments(expression))
+        //     return ExpressionWithArgumentTransformer.transform(
+        //         project,
+        //         expression,
+        //     );
+        return expression;
+    }
+}

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

@@ -59,13 +59,15 @@ export namespace ApplicationTransformer {
         // GENERATORS
         //----
         // METADATA
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
+        const collection: MetadataCollection = new MetadataCollection();
         const metadatas: Array<Metadata> = types.map((type) =>
             MetadataFactory.generate(checker, collection, type, {
                 resolve: true,
                 constant: true,
+                validate: (meta) => {
+                    if (meta.atomics.find((str) => str === "bigint"))
+                        throw new Error(ErrorMessages.NO_BIGIT);
+                },
             }),
         );
 
@@ -111,4 +113,5 @@ export namespace ApplicationTransformer {
 const enum ErrorMessages {
     NO_GENERIC_ARGUMENT = "Error on typia.application(): no generic argument.",
     GENERIC_ARGUMENT = "Error on typia.application(): non-specified generic argument(s).",
+    NO_BIGIT = "Error on typia.application(): does not allow bigint type.",
 }

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

@@ -1,55 +1,55 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProject } from "../../IProject";
-
-export namespace MetadataTransformer {
-    export function transform(
-        { checker }: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (!expression.typeArguments?.length)
-            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
-
-        // VALIDATE TUPLE ARGUMENTS
-        const top: ts.Node = expression.typeArguments[0]!;
-        if (!ts.isTupleTypeNode(top)) return expression;
-        else if (top.elements.some((child) => !ts.isTypeNode(child)))
-            return expression;
-
-        // GET TYPES
-        const types: ts.Type[] = top.elements.map((child) =>
-            checker.getTypeFromTypeNode(child as ts.TypeNode),
-        );
-        if (types.some((t) => t.isTypeParameter()))
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // METADATA
-        const collection: MetadataCollection = new MetadataCollection();
-        const metadatas: Array<Metadata> = types.map((type) =>
-            MetadataFactory.generate(checker, collection, type, {
-                resolve: false,
-                constant: true,
-            }),
-        );
-
-        // CONVERT TO PRIMITIVE TYPE
-        const app: IMetadataApplication = {
-            metadatas: metadatas.map((metadata) => metadata.toJSON()),
-            collection: collection.objects().map((obj) => obj.toJSON()),
-        };
-        return LiteralFactory.generate(app);
-    }
-}
-
-const enum ErrorMessages {
-    NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.",
-    GENERIC_ARGUMENT = "Error on typia.metadata(): non-specified generic argument(s).",
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProject } from "../../IProject";
+
+export namespace MetadataTransformer {
+    export function transform(
+        { checker }: IProject,
+        _modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.length)
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        // VALIDATE TUPLE ARGUMENTS
+        const top: ts.Node = expression.typeArguments[0]!;
+        if (!ts.isTupleTypeNode(top)) return expression;
+        else if (top.elements.some((child) => !ts.isTypeNode(child)))
+            return expression;
+
+        // GET TYPES
+        const types: ts.Type[] = top.elements.map((child) =>
+            checker.getTypeFromTypeNode(child as ts.TypeNode),
+        );
+        if (types.some((t) => t.isTypeParameter()))
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // METADATA
+        const collection: MetadataCollection = new MetadataCollection();
+        const metadatas: Array<Metadata> = types.map((type) =>
+            MetadataFactory.generate(checker, collection, type, {
+                resolve: false,
+                constant: true,
+            }),
+        );
+
+        // CONVERT TO PRIMITIVE TYPE
+        const app: IMetadataApplication = {
+            metadatas: metadatas.map((metadata) => metadata.toJSON()),
+            collection: collection.objects().map((obj) => obj.toJSON()),
+        };
+        return LiteralFactory.generate(app);
+    }
+}
+
+const enum ErrorMessages {
+    NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.",
+    GENERIC_ARGUMENT = "Error on typia.metadata(): non-specified generic argument(s).",
+}

package/src/transformers/features/parsers/AssertParseTransformer.ts

@@ -1,36 +1,36 @@
-import ts from "typescript";
-
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace AssertParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return ts.factory.createCallExpression(
-            AssertParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified",
-    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace AssertParseTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            AssertParseProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified",
+    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
+}