typia 3.8.0-dev.20230417 → 3.8.0-dev.20230420

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

@@ -1,30 +1,28 @@
-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 const transform =
+        (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 = project.checker.getTypeFromTypeNode(node);
+
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return LiteralsProgrammer.write(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,52 @@
-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 const transform =
+        ({ 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 (!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.analyze(checker)({
+                    resolve: false,
+                    constant: true,
+                })(collection)(type),
+            );
+
+            // 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/PruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace PruneTransformer {
     export const transform = GenericTransformer.scalar("prune")(
-        (project, modulo) => PruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
     );
 }

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

@@ -1,46 +1,42 @@
-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 const 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.write({
+                    ...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/transformers/features/miscellaneous/ValidateCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidateCloneTransformer {
     export const transform = GenericTransformer.scalar("validatClone")(
-        (project, modulo) => ValidateCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidatePruneTransformer {
     export const transform = GenericTransformer.scalar("validatPrune")(
-        (project, modulo) => ValidatePruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertParseTransformer {
     export const transform = GenericTransformer.scalar("assertParse")(
-        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertParseTransformer {
     export const transform = GenericTransformer.factory("createAssertParse")(
-        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsParseTransformer {
     export const transform = GenericTransformer.factory("createIsParse")(
-        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateParseTransformer {
     export const transform = GenericTransformer.factory("createValidateParse")(
-        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsParseTransformer {
     export const transform = GenericTransformer.scalar("isParse")(
-        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
     );
 }

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

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidateParseTransformer {
     export const transform = GenericTransformer.scalar("validatParse")(
-        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/AssertStringifyTransformer.ts

@@ -4,7 +4,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertStringifyTransformer {
     export const transform = GenericTransformer.scalar("assertStringify")(
-        (project, modulo) =>
-            AssertStringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) =>
+            AssertStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts

@@ -5,5 +5,8 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 export namespace CreateAssertStringifyTransformer {
     export const transform = GenericTransformer.factory(
         "createAssertStringify",
-    )((project, modulo) => AssertStringifyProgrammer.generate(project, modulo));
+    )(
+        (project) => (modulo) =>
+            AssertStringifyProgrammer.write(project)(modulo),
+    );
 }

package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsStringifyTransformer {
     export const transform = GenericTransformer.factory("createIsStringify")(
-        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/CreateStringifyTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateStringifyTransformer {
     export const transform = GenericTransformer.factory("createStringify")(
-        (project, modulo) => StringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/CreateValidateStringifyProgrammer.ts

@@ -5,7 +5,8 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 export namespace CreateValidateStringifyTransformer {
     export const transform = GenericTransformer.factory(
         "createValidateStringify",
-    )((project, modulo) =>
-        ValidateStringifyProgrammer.generate(project, modulo),
+    )(
+        (project) => (modulo) =>
+            ValidateStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/IsStringifyTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsStringifyTransformer {
     export const transform = GenericTransformer.scalar("isStringify")(
-        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/StringifyTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace StringifyTransformer {
     export const transform = GenericTransformer.scalar("stringify")(
-        (project, modulo) => StringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/ValidateStringifyTransformer.ts

@@ -4,7 +4,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidateStringifyTransformer {
     export const transform = GenericTransformer.scalar("validatStringify")(
-        (project, modulo) =>
-            ValidateStringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) =>
+            ValidateStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/validators/AssertTransformer.ts

@@ -5,7 +5,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 export namespace AssertTransformer {
     export const transform = (equals: boolean) =>
         GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
-            (project, modulo) =>
-                AssertProgrammer.generate(project, modulo, equals),
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
         );
 }

package/src/transformers/features/validators/CreateAssertTransformer.ts

@@ -6,7 +6,8 @@ export namespace CreateAssertTransformer {
     export const transform = (equals: boolean) =>
         GenericTransformer.factory(
             equals ? "createAssertEquals" : "createAssert",
-        )((project, modulo) =>
-            AssertProgrammer.generate(project, modulo, equals),
+        )(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
         );
 }

package/src/transformers/features/validators/CreateIsTransformer.ts

@@ -5,6 +5,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 export namespace CreateIsTransformer {
     export const transform = (equals: boolean) =>
         GenericTransformer.factory(equals ? "createEquals" : "createIs")(
-            (project, modulo) => IsProgrammer.generate(project, modulo, equals),
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
         );
 }

package/src/transformers/features/validators/CreateValidateTransformer.ts

@@ -6,7 +6,8 @@ export namespace CreateValidateTransformer {
     export const transform = (equals: boolean) =>
         GenericTransformer.factory(
             equals ? "createValidateEquals" : "createValidate",
-        )((project, modulo) =>
-            ValidateProgrammer.generate(project, modulo, equals),
+        )(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
         );
 }

package/src/transformers/features/validators/IsTransformer.ts

@@ -4,7 +4,8 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsTransformer {
     export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "equals" : "is")((project, modulo) =>
-            IsProgrammer.generate(project, modulo, equals),
+        GenericTransformer.scalar(equals ? "equals" : "is")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
         );
 }

package/src/transformers/features/validators/ValidateTransformer.ts

@@ -5,7 +5,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 export namespace ValidateTransformer {
     export const transform = (equals: boolean) =>
         GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
-            (project, modulo) =>
-                ValidateProgrammer.generate(project, modulo, equals),
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
         );
 }

package/src/transformers/internal/GenericTransformer.ts

@@ -8,14 +8,13 @@ export namespace GenericTransformer {
         (
             programmer: (
                 project: IProject,
+            ) => (
                 modulo: ts.LeftHandSideExpression,
             ) => (type: ts.Type, name: string) => ts.ArrowFunction,
         ) =>
-        (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ) => {
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
             // CHECK PARAMETER
             if (expression.arguments.length !== 1)
                 throw new Error(`Error on typia.${method}(): no input value.`);
@@ -44,7 +43,7 @@ export namespace GenericTransformer {
 
             // DO TRANSFORM
             return ts.factory.createCallExpression(
-                programmer(project, modulo)(
+                programmer(project)(modulo)(
                     type,
                     generic
                         ? node.getFullText().trim()
@@ -60,14 +59,13 @@ export namespace GenericTransformer {
         (
             programmer: (
                 project: IProject,
+            ) => (
                 modulo: ts.LeftHandSideExpression,
             ) => (type: ts.Type, name: string) => ts.ArrowFunction,
         ) =>
-        (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ) => {
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments?.[0])
                 throw new Error(
@@ -84,7 +82,7 @@ export namespace GenericTransformer {
                 );
 
             // DO TRANSFORM
-            return programmer(project, modulo)(type, node.getFullText().trim());
+            return programmer(project)(modulo)(type, node.getFullText().trim());
         };
 
     const name =

package/src/typings/Customizable.ts

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

package/src/utils/ArrayUtil.ts

@@ -1,49 +1,44 @@
 export namespace ArrayUtil {
-    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
-        return array.some(pred);
-    }
+    export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
+        array.some(pred);
 
-    export function add<T>(
+    export const add = <T>(
         array: T[],
         value: T,
         pred: (x: T, y: T) => boolean = (x, y) => x === y,
-    ): void {
+    ): void => {
         if (array.some((elem) => pred(elem, value))) return;
         array.push(value);
-    }
+    };
 
-    export function set<Key, T>(
+    export const set = <Key, T>(
         array: T[],
         value: T,
         key: (elem: T) => Key,
-    ): void {
+    ): void => {
         if (array.some((elem) => key(elem) === key(value))) return;
         array.push(value);
-    }
+    };
 
-    export function take<T>(
+    export const take = <T>(
         array: T[],
         pred: (elem: T) => boolean,
         init: () => T,
-    ): T {
+    ): T => {
         const index: number = array.findIndex(pred);
         if (index !== -1) return array[index]!;
 
         const elem: T = init();
         array.push(elem);
         return elem;
-    }
+    };
 
-    export function repeat<T>(
+    export const repeat = <T>(
         count: number,
         closure: (index: number, count: number) => T,
-    ): T[] {
-        return new Array(count)
-            .fill("")
-            .map((_, index) => closure(index, count));
-    }
+    ): T[] =>
+        new Array(count).fill("").map((_, index) => closure(index, count));
 
-    export function flat<T>(matrix: T[][]): T[] {
-        return ([] as T[]).concat(...matrix);
-    }
+    export const flat = <T>(matrix: T[][]): T[] =>
+        ([] as T[]).concat(...matrix);
 }