typia 3.8.0-dev.20230415 → 3.8.0-dev.20230417

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

@@ -1,119 +1,119 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { IJsonApplication } from "../../../schemas/IJsonApplication";
-
-import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace ApplicationTransformer {
-    export function transform(
-        { checker }: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (!expression.typeArguments?.length)
-            throw new Error(NO_GENERIC_ARGUMENT);
-
-        //----
-        // GET ARGUMENTS
-        //----
-        // 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(GENERIC_ARGUMENT);
-
-        // ADDITIONAL PARAMETERS
-        const purpose: "swagger" | "ajv" = get_parameter(
-            checker,
-            "Purpose",
-            expression.typeArguments[1],
-            (str) => str === "swagger" || str === "ajv",
-            () => "swagger",
-        );
-        const prefix: string = get_parameter(
-            checker,
-            "Prefix",
-            expression.typeArguments[2],
-            () => true,
-            () =>
-                purpose === "swagger"
-                    ? "#/components/schemas"
-                    : "components#/schemas",
-        );
-
-        //----
-        // GENERATORS
-        //----
-        // METADATA
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
-        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(NO_BIGIT);
-                },
-            }),
-        );
-
-        // APPLICATION
-        const app: IJsonApplication = ApplicationProgrammer.generate(
-            metadatas,
-            {
-                purpose,
-                prefix,
-            },
-        );
-
-        // RETURNS WITH LITERAL EXPRESSION
-        return LiteralFactory.generate(app);
-    }
-
-    function get_parameter<T extends string>(
-        checker: ts.TypeChecker,
-        name: string,
-        node: ts.TypeNode | undefined,
-        predicator: (value: string) => boolean,
-        defaulter: () => T,
-    ): T {
-        if (!node) return defaulter();
-
-        // CHECK LITERAL TYPE
-        const type: ts.Type = checker.getTypeFromTypeNode(node);
-        if (!type.isLiteral())
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
-
-        // GET VALUE AND VALIDATE IT
-        const value = type.value;
-        if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
-        return value as T;
-    }
-}
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.application(): non-specified generic argument(s).";
-const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { IJsonApplication } from "../../../schemas/IJsonApplication";
+
+import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ApplicationTransformer {
+    export function transform(
+        { checker }: IProject,
+        _modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.length)
+            throw new Error(NO_GENERIC_ARGUMENT);
+
+        //----
+        // GET ARGUMENTS
+        //----
+        // 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(GENERIC_ARGUMENT);
+
+        // ADDITIONAL PARAMETERS
+        const purpose: "swagger" | "ajv" = get_parameter(
+            checker,
+            "Purpose",
+            expression.typeArguments[1],
+            (str) => str === "swagger" || str === "ajv",
+            () => "swagger",
+        );
+        const prefix: string = get_parameter(
+            checker,
+            "Prefix",
+            expression.typeArguments[2],
+            () => true,
+            () =>
+                purpose === "swagger"
+                    ? "#/components/schemas"
+                    : "components#/schemas",
+        );
+
+        //----
+        // GENERATORS
+        //----
+        // METADATA
+        const collection: MetadataCollection = new MetadataCollection({
+            replace: MetadataCollection.replace,
+        });
+        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(NO_BIGIT);
+                },
+            }),
+        );
+
+        // APPLICATION
+        const app: IJsonApplication = ApplicationProgrammer.generate(
+            metadatas,
+            {
+                purpose,
+                prefix,
+            },
+        );
+
+        // RETURNS WITH LITERAL EXPRESSION
+        return LiteralFactory.generate(app);
+    }
+
+    function get_parameter<T extends string>(
+        checker: ts.TypeChecker,
+        name: string,
+        node: ts.TypeNode | undefined,
+        predicator: (value: string) => boolean,
+        defaulter: () => T,
+    ): T {
+        if (!node) return defaulter();
+
+        // CHECK LITERAL TYPE
+        const type: ts.Type = checker.getTypeFromTypeNode(node);
+        if (!type.isLiteral())
+            throw new Error(
+                `Error on typia.application(): generic argument "${name}" must be constant.`,
+            );
+
+        // GET VALUE AND VALIDATE IT
+        const value = type.value;
+        if (typeof value !== "string" || predicator(value) === false)
+            throw new Error(
+                `Error on typia.application(): invalid value on generic argument "${name}".`,
+            );
+        return value as T;
+    }
+}
+
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.application(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.application(): non-specified generic argument(s).";
+const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";

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

@@ -1,41 +1,41 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateRandomTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        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 = project.checker.getTypeFromTypeNode(node);
-
-        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return RandomProgrammer.generate(
-            {
-                ...project,
-                options: {
-                    ...project.options,
-                    functional: false,
-                    numeric: false,
-                },
-            },
-            modulo,
-            expression.arguments?.[0],
-        )(type, node.getFullText().trim());
-    }
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.createRandom(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.createRandom(): non-specified generic argument.";
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateRandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        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 = project.checker.getTypeFromTypeNode(node);
+
+        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return RandomProgrammer.generate(
+            {
+                ...project,
+                options: {
+                    ...project.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            modulo,
+            expression.arguments?.[0],
+        )(type, node.getFullText().trim());
+    }
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.createRandom(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.createRandom(): non-specified generic argument.";

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

@@ -1,30 +1,30 @@
-import ts from "typescript";
-
-import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace LiteralsTransformer {
-    export function transform(
-        project: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        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 = project.checker.getTypeFromTypeNode(node);
-
-        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return LiteralsProgrammer.generate(project)(type);
-    }
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.literals(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.literals(): non-specified generic argument.";
+import ts from "typescript";
+
+import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace LiteralsTransformer {
+    export function transform(
+        project: IProject,
+        _modulo: ts.LeftHandSideExpression,
+        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 = project.checker.getTypeFromTypeNode(node);
+
+        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return LiteralsProgrammer.generate(project)(type);
+    }
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.literals(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.literals(): non-specified generic argument.";

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

@@ -1,54 +1,54 @@
-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(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(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 NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
-const 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(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(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 NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.metadata(): non-specified generic argument(s).";

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

@@ -1,46 +1,46 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace RandomTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        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 = project.checker.getTypeFromTypeNode(node);
-
-        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return ts.factory.createCallExpression(
-            RandomProgrammer.generate(
-                {
-                    ...project,
-                    options: {
-                        ...project.options,
-                        functional: false,
-                        numeric: false,
-                    },
-                },
-                modulo,
-            )(type, node.getFullText().trim()),
-            undefined,
-            expression.arguments.length
-                ? [expression.arguments[0]!]
-                : undefined,
-        );
-    }
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.random(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.random(): non-specified generic argument.";
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace RandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        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 = project.checker.getTypeFromTypeNode(node);
+
+        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            RandomProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                },
+                modulo,
+            )(type, node.getFullText().trim()),
+            undefined,
+            expression.arguments.length
+                ? [expression.arguments[0]!]
+                : undefined,
+        );
+    }
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.random(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.random(): non-specified generic argument.";

package/src/typings/Customizable.ts

@@ -1,5 +1,5 @@
-export type Customizable = {
-    number: number;
-    string: string;
-    bigint: bigint;
-};
+export interface Customizable {
+    number: number;
+    string: string;
+    bigint: bigint;
+}