typia 3.8.0-dev.20230418 → 3.8.0-dev.20230420

package/src/programmers/internal/check_string_tags.ts

@@ -1,67 +1,67 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_string_tags =
-    (importer: FunctionImporter) =>
-    (tagList: IMetadataTag[]) =>
-    (input: ts.Expression): ICheckEntry.ITag[] => {
-        const conditions: [IMetadataTag, ts.Expression][] = [];
-        for (const tag of tagList)
-            if (tag.kind === "format")
-                conditions.push([
-                    tag,
-                    ts.factory.createCallExpression(
-                        importer.use(`is_${tag.value}`),
-                        undefined,
-                        [input],
-                    ),
-                ]);
-            else if (tag.kind === "pattern")
-                conditions.push([
-                    tag,
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(
-                            `RegExp(/${tag.value}/).test`,
-                        ),
-                        undefined,
-                        [input],
-                    ),
-                ]);
-            else if (tag.kind === "length")
-                conditions.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.join(input, "length"),
-                    ),
-                ]);
-            else if (tag.kind === "minLength")
-                conditions.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.join(input, "length"),
-                    ),
-                ]);
-            else if (tag.kind === "maxLength")
-                conditions.push([
-                    tag,
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.join(input, "length"),
-                    ),
-                ]);
-        return conditions.map(([tag, expression]) => ({
-            expected: `string (@${tag.kind} ${tag.value})`,
-            expression,
-        }));
-    };
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_string_tags =
+    (importer: FunctionImporter) =>
+    (tagList: IMetadataTag[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] => {
+        const conditions: [IMetadataTag, ts.Expression][] = [];
+        for (const tag of tagList)
+            if (tag.kind === "format")
+                conditions.push([
+                    tag,
+                    ts.factory.createCallExpression(
+                        importer.use(`is_${tag.value}`),
+                        undefined,
+                        [input],
+                    ),
+                ]);
+            else if (tag.kind === "pattern")
+                conditions.push([
+                    tag,
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(
+                            `RegExp(/${tag.value}/).test`,
+                        ),
+                        undefined,
+                        [input],
+                    ),
+                ]);
+            else if (tag.kind === "length")
+                conditions.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input)("length"),
+                    ),
+                ]);
+            else if (tag.kind === "minLength")
+                conditions.push([
+                    tag,
+                    ts.factory.createLessThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input)("length"),
+                    ),
+                ]);
+            else if (tag.kind === "maxLength")
+                conditions.push([
+                    tag,
+                    ts.factory.createGreaterThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input)("length"),
+                    ),
+                ]);
+        return conditions.map(([tag, expression]) => ({
+            expected: `string (@${tag.kind} ${tag.value})`,
+            expression,
+        }));
+    };

package/src/programmers/internal/check_template.ts

@@ -1,56 +1,56 @@
-import ts from "typescript";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-import { Metadata } from "../../metadata/Metadata";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
-import { check_string_tags } from "./check_string_tags";
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const check_template =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
-    (templates: Metadata[][]) =>
-    (input: ts.Expression): ICheckEntry => {
-        // TYPEOF STRING & TAGS
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-
-        // TEMPLATES
-        const internal: ts.Expression[] = templates.map((tpl) =>
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                    `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
-                ),
-                undefined,
-                [input],
-            ),
-        );
-        conditions.push(
-            internal.length === 1
-                ? internal[0]!
-                : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
-        );
-
-        // COMBINATION
-        return {
-            expression: conditions.reduce((x, y) =>
-                ts.factory.createLogicalAnd(x, y),
-            ),
-            tags: [
-                ...check_string_tags(importer)(metaTags)(input),
-                ...check_custom("string")(importer)(jsDocTags)(input),
-            ],
-        };
-    };
+import ts from "typescript";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
+import { check_string_tags } from "./check_string_tags";
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_template =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (templates: Metadata[][]) =>
+    (input: ts.Expression): ICheckEntry => {
+        // TYPEOF STRING & TAGS
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // TEMPLATES
+        const internal: ts.Expression[] = templates.map((tpl) =>
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
+                ),
+                undefined,
+                [input],
+            ),
+        );
+        conditions.push(
+            internal.length === 1
+                ? internal[0]!
+                : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
+        );
+
+        // COMBINATION
+        return {
+            expression: conditions.reduce((x, y) =>
+                ts.factory.createLogicalAnd(x, y),
+            ),
+            tags: [
+                ...check_string_tags(importer)(metaTags)(input),
+                ...check_custom("string")(importer)(jsDocTags)(input),
+            ],
+        };
+    };

package/src/programmers/internal/check_union_array_like.ts

@@ -151,8 +151,7 @@ export const check_union_array_like =
                 ts.factory.createCallExpression(
                     IdentifierFactory.join(
                         ts.factory.createIdentifier("array"),
-                        "every",
-                    ),
+                    )("every"),
                     undefined,
                     [
                         ts.factory.createArrowFunction(

package/src/programmers/internal/check_union_tuple.ts

@@ -13,11 +13,9 @@ import { FunctionImporter } from "../helpers/FunctionImporeter";
  * @todo Faster union checking logic is required
  */
 export const check_union_tuple =
-    (
-        project: IProject,
-        config: CheckerProgrammer.IConfig,
-        importer: FunctionImporter,
-    ) =>
+    (project: IProject) =>
+    (config: CheckerProgrammer.IConfig) =>
+    (importer: FunctionImporter) =>
     (
         _front: ts.Expression,
         elements: Metadata[],
@@ -26,7 +24,7 @@ export const check_union_tuple =
         jsDocTags: ts.JSDocTagInfo[],
         array: ts.Expression,
     ) =>
-        CheckerProgrammer.decode_tuple(project, config, importer, true)(
+        CheckerProgrammer.decode_tuple(project)(config)(importer)(true)(
             array,
             elements,
             explore,

package/src/programmers/internal/random_custom.ts

@@ -26,5 +26,4 @@ export const random_custom =
                 undefined,
                 [LiteralFactory.generate(comments)],
             ),
-            expression,
-        );
+        )(expression);

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -9,10 +9,10 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 /**
  * @internal
  */
-export function stringify_dynamic_properties(
+export const stringify_dynamic_properties = (
     dynamic: IExpressionEntry<ts.Expression>[],
     regular: string[],
-): ts.Expression {
+): ts.Expression => {
     // BASIC STATMEMENT, CHECK UNDEFINED
     const statements: ts.Statement[] = [
         ts.factory.createIfStatement(
@@ -35,8 +35,7 @@ export function stringify_dynamic_properties(
                     undefined,
                     [ts.factory.createIdentifier("input")],
                 ),
-                "map",
-            ),
+            )("map"),
             undefined,
             [
                 ts.factory.createArrowFunction(
@@ -66,7 +65,7 @@ export function stringify_dynamic_properties(
             ],
         );
         const filtered = ts.factory.createCallExpression(
-            IdentifierFactory.join(mapped, "filter"),
+            IdentifierFactory.join(mapped)("filter"),
             undefined,
             [
                 ts.factory.createArrowFunction(
@@ -83,7 +82,7 @@ export function stringify_dynamic_properties(
             ],
         );
         return ts.factory.createCallExpression(
-            IdentifierFactory.join(filtered, "join"),
+            IdentifierFactory.join(filtered)("join"),
             undefined,
             [ts.factory.createStringLiteral(",")],
         );
@@ -100,8 +99,7 @@ export function stringify_dynamic_properties(
                                 ts.factory.createStringLiteral(key),
                             ),
                         ),
-                        "some",
-                    ),
+                    )("some"),
                     undefined,
                     [
                         ts.factory.createArrowFunction(
@@ -148,13 +146,15 @@ export function stringify_dynamic_properties(
         statements.push(condition);
     }
     return output();
-}
+};
 
 /**
  * @internal
  */
-function stringify(entry: IExpressionEntry<ts.Expression>): ts.ReturnStatement {
-    return ts.factory.createReturnStatement(
+const stringify = (
+    entry: IExpressionEntry<ts.Expression>,
+): ts.ReturnStatement =>
+    ts.factory.createReturnStatement(
         TemplateFactory.generate([
             ts.factory.createCallExpression(
                 ts.factory.createIdentifier("JSON.stringify"),
@@ -165,4 +165,3 @@ function stringify(entry: IExpressionEntry<ts.Expression>): ts.ReturnStatement {
             entry.expression,
         ]),
     );
-}

package/src/programmers/internal/stringify_native.ts

@@ -3,6 +3,5 @@ import ts from "typescript";
 /**
  * @internal
  */
-export function stringify_native(): ts.Expression {
-    return ts.factory.createStringLiteral("{}");
-}
+export const stringify_native = (): ts.Expression =>
+    ts.factory.createStringLiteral("{}");

package/src/programmers/internal/stringify_regular_properties.ts

@@ -10,10 +10,10 @@ import { IExpressionEntry } from "../helpers/IExpressionEntry";
 /**
  * @internal
  */
-export function stringify_regular_properties(
+export const stringify_regular_properties = (
     regular: IExpressionEntry<ts.Expression>[],
     dynamic: IExpressionEntry<ts.Expression>[],
-): ts.Expression[] {
+): ts.Expression[] => {
     const output: ts.Expression[] = [];
 
     regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
@@ -74,11 +74,10 @@ export function stringify_regular_properties(
         else output.push(...base);
     });
     return output;
-}
+};
 
 /**
  * @internal
  */
-function sequence(meta: Metadata): number {
-    return meta.any || !meta.required || meta.functional ? 0 : 1;
-}
+const sequence = (meta: Metadata): number =>
+    meta.any || !meta.required || meta.functional ? 0 : 1;

package/src/transform.ts

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

package/src/transformers/CallExpressionTransformer.ts

@@ -45,47 +45,49 @@ import { IsTransformer } from "./features/validators/IsTransformer";
 import { ValidateTransformer } from "./features/validators/ValidateTransformer";
 
 export namespace CallExpressionTransformer {
-    export function transform(
-        project: IProject,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        //----
-        // VALIDATIONS
-        //----
-        // SIGNATURE DECLARATION
-        const declaration: ts.Declaration | undefined =
-            project.checker.getResolvedSignature(expression)?.declaration;
-        if (!declaration) return expression;
-
-        // FILE PATH
-        const file: string = path.resolve(declaration.getSourceFile().fileName);
-        if (
-            file.indexOf(LIB_PATH) === -1 &&
-            file !== SRC_PATH &&
-            file !== CLI_PATH
-        )
-            return expression;
-
-        //----
-        // TRANSFORMATION
-        //----
-        // 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, expression.expression, expression);
-    }
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            //----
+            // VALIDATIONS
+            //----
+            // SIGNATURE DECLARATION
+            const declaration: ts.Declaration | undefined =
+                project.checker.getResolvedSignature(expression)?.declaration;
+            if (!declaration) return expression;
+
+            // FILE PATH
+            const file: string = path.resolve(
+                declaration.getSourceFile().fileName,
+            );
+            if (
+                file.indexOf(LIB_PATH) === -1 &&
+                file !== SRC_PATH &&
+                file !== CLI_PATH
+            )
+                return expression;
+
+            //----
+            // TRANSFORMATION
+            //----
+            // 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)(expression.expression)(expression);
+        };
 }
 
 type Task = (
     project: IProject,
+) => (
     modulo: ts.LeftHandSideExpression,
-    expression: ts.CallExpression,
-) => ts.Expression;
+) => (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, "..", "module.ts"));
@@ -114,16 +116,17 @@ const FUNCTORS: Record<string, () => Task> = {
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
-    application: () => ApplicationTransformer.transform,
+    application: () => (project) => () =>
+        ApplicationTransformer.transform(project),
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
     validateStringify: () => ValidateStringifyTransformer.transform,
 
     // MISC
-    metadata: () => MetadataTransformer.transform,
+    metadata: () => (project) => () => MetadataTransformer.transform(project),
     random: () => RandomTransformer.transform,
-    literals: () => LiteralsTransformer.transform,
+    literals: () => (project) => () => LiteralsTransformer.transform(project),
 
     clone: () => CloneTransformer.transform,
     assertClone: () => AssertCloneTransformer.transform,

package/src/transformers/FileTransformer.ts

@@ -4,46 +4,44 @@ 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;
+    export const transform =
+        (project: IProject) =>
+        (context: ts.TransformationContext) =>
+        (file: ts.SourceFile): ts.SourceFile =>
+            file.isDeclarationFile
+                ? file
+                : ts.visitEachChild(
+                      file,
+                      (node) => iterate_node(project)(context)(node),
+                      context,
+                  );
 
-        // 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,
-        );
-    }
+    const iterate_node =
+        (project: IProject) =>
+        (context: ts.TransformationContext) =>
+        (node: ts.Node): ts.Node =>
+            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 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;
-        }
-    }
+                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/NodeTransformer.ts

@@ -3,17 +3,11 @@ 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;
-    }
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.Node): ts.Node =>
+            ts.isCallExpression(expression)
+                ? CallExpressionTransformer.transform(project)(expression)
+                : expression;
 }