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

package/src/programmers/ValidateProgrammer.ts

@@ -14,53 +14,59 @@ import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
 
 export namespace ValidateProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (
             project: IProject,
             modulo: ts.LeftHandSideExpression,
             equals: boolean = false,
         ) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(equals)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (equals: boolean) =>
         (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
-            const program: ts.ArrowFunction = CheckerProgrammer.generate(
-                project,
-                {
-                    functors: "$vo",
-                    unioners: "$vu",
-                    path: true,
-                    trace: true,
-                    numeric: OptionPredicator.numeric(project.options),
-                    equals,
-                    atomist: (explore) => (tuple) => (input) =>
-                        [
-                            tuple.expression,
-                            ...tuple.tags.map((tag) =>
-                                ts.factory.createLogicalOr(
-                                    tag.expression,
-                                    create_report_call(
-                                        explore.from === "top"
-                                            ? ts.factory.createTrue()
-                                            : ts.factory.createIdentifier(
-                                                  "_exceptionable",
-                                              ),
-                                    )(
-                                        ts.factory.createIdentifier(
-                                            explore.postfix
-                                                ? `_path + ${explore.postfix}`
-                                                : "_path",
-                                        ),
-                                        tag.expected,
-                                        input,
+            const program: ts.ArrowFunction = CheckerProgrammer.write(project)({
+                functors: "$vo",
+                unioners: "$vu",
+                path: true,
+                trace: true,
+                numeric: OptionPredicator.numeric(project.options),
+                equals,
+                atomist: (explore) => (tuple) => (input) =>
+                    [
+                        tuple.expression,
+                        ...tuple.tags.map((tag) =>
+                            ts.factory.createLogicalOr(
+                                tag.expression,
+                                create_report_call(
+                                    explore.from === "top"
+                                        ? ts.factory.createTrue()
+                                        : ts.factory.createIdentifier(
+                                              "_exceptionable",
+                                          ),
+                                )(
+                                    ts.factory.createIdentifier(
+                                        explore.postfix
+                                            ? `_path + ${explore.postfix}`
+                                            : "_path",
                                     ),
+                                    tag.expected,
+                                    input,
                                 ),
                             ),
-                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-                    combiner: combine(equals)(importer),
-                    joiner: joiner(equals)(importer),
-                    success: ts.factory.createTrue(),
-                },
-                importer,
-            )(type, name);
+                        ),
+                    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                combiner: combine(equals)(importer),
+                joiner: joiner(equals)(importer),
+                success: ts.factory.createTrue(),
+            })(importer)(type, name);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -73,7 +79,7 @@ export namespace ValidateProgrammer {
                 ],
                 ts.factory.createTypeReferenceNode(
                     `typia.IValidation<${
-                        name ?? TypeFactory.getFullName(project.checker, type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
@@ -81,15 +87,10 @@ export namespace ValidateProgrammer {
                     [
                         StatementFactory.constant(
                             "__is",
-                            IsProgrammer.generate(
-                                project,
-                                modulo,
-                                equals,
-                            )(
+                            IsProgrammer.write(project)(modulo)(equals)(
                                 type,
                                 name ??
-                                    TypeFactory.getFullName(
-                                        project.checker,
+                                    TypeFactory.getFullName(project.checker)(
                                         type,
                                     ),
                             ),
@@ -113,8 +114,7 @@ export namespace ValidateProgrammer {
                                             TypeFactory.keyword("any"),
                                         ),
                                     ),
-                                    "report",
-                                ),
+                                )("report"),
                                 [],
                                 [ts.factory.createIdentifier("errors")],
                             ),
@@ -168,7 +168,7 @@ const combine =
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
         if (explore.tracable === false)
-            return IsProgrammer.CONFIG({
+            return IsProgrammer.configure({
                 object: validate_object(equals)(importer),
                 numeric: true,
             })(importer).combiner(explore);
@@ -247,7 +247,7 @@ const joiner =
         array: (input, arrow) =>
             check_everything(
                 ts.factory.createCallExpression(
-                    IdentifierFactory.join(input, "map"),
+                    IdentifierFactory.join(input)("map"),
                     undefined,
                     [arrow],
                 ),
@@ -270,8 +270,8 @@ const joiner =
             ),
     });
 
-function create_output() {
-    return ts.factory.createObjectLiteralExpression(
+const create_output = () =>
+    ts.factory.createObjectLiteralExpression(
         [
             ts.factory.createShorthandPropertyAssignment("success"),
             ts.factory.createShorthandPropertyAssignment("errors"),
@@ -288,7 +288,6 @@ function create_output() {
         ],
         true,
     );
-}
 
 const create_report_call =
     (exceptionable?: ts.Expression) =>

package/src/programmers/ValidatePruneProgrammer.ts

@@ -10,8 +10,17 @@ import { PruneProgrammer } from "./PruneProgrammer";
 import { ValidateProgrammer } from "./ValidateProgrammer";
 
 export namespace ValidatePruneProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
@@ -24,38 +33,32 @@ export namespace ValidatePruneProgrammer {
                 ],
                 ts.factory.createTypeReferenceNode(
                     `typia.IValidation<${
-                        name ?? TypeFactory.getFullName(project.checker, type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "validate",
-                        ValidateProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: true,
-                                },
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "prune",
-                        PruneProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        PruneProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(type, name),
                     ),
                     StatementFactory.constant(
                         "output",

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -10,8 +10,17 @@ import { StringifyProgrammer } from "./StringifyProgrammer";
 import { ValidateProgrammer } from "./ValidateProgrammer";
 
 export namespace ValidateStringifyProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
@@ -21,7 +30,7 @@ export namespace ValidateStringifyProgrammer {
                         "input",
                         ts.factory.createTypeReferenceNode(
                             name ??
-                                TypeFactory.getFullName(project.checker, type),
+                                TypeFactory.getFullName(project.checker)(type),
                         ),
                     ),
                 ],
@@ -30,31 +39,25 @@ export namespace ValidateStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "validate",
-                        ValidateProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: true,
-                                },
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "stringify",
-                        StringifyProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        StringifyProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(type, name),
                     ),
                     StatementFactory.constant(
                         "output",

package/src/programmers/helpers/CloneJoiner.ts

@@ -3,8 +3,6 @@ import ts from "typescript";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { MetadataObject } from "../../metadata/MetadataObject";
-
 import { Escaper } from "../../utils/Escaper";
 
 import { metadata_to_pattern } from "../internal/metadata_to_pattern";
@@ -14,7 +12,6 @@ export namespace CloneJoiner {
     export const object = (
         input: ts.Expression,
         entries: IExpressionEntry<ts.Expression>[],
-        _obj: MetadataObject,
     ): ts.ConciseBody => {
         if (entries.length === 0) return ts.factory.createIdentifier("{}");
 

package/src/programmers/helpers/FunctionImporeter.ts

@@ -38,8 +38,7 @@ export class FunctionImporter {
                             TypeFactory.keyword("any"),
                         ),
                     ),
-                    name,
-                ),
+                )(name),
             ),
         );
     }

package/src/programmers/helpers/OptionPredicator.ts

@@ -1,19 +1,15 @@
 import { ITransformOptions } from "../../transformers/ITransformOptions";
 
 export namespace OptionPredicator {
-    export function numeric(options: ITransformOptions): boolean {
-        return finite(options) || options.numeric === true;
-    }
+    export const numeric = (options: ITransformOptions): boolean =>
+        finite(options) || options.numeric === true;
 
-    export function functional(options: ITransformOptions): boolean {
-        return options.functional === true;
-    }
+    export const functional = (options: ITransformOptions): boolean =>
+        options.functional === true;
 
-    export function finite(options: ITransformOptions): boolean {
-        return options.finite === true;
-    }
+    export const finite = (options: ITransformOptions): boolean =>
+        options.finite === true;
 
-    export function undefined(options: ITransformOptions): boolean {
-        return options.undefined !== false;
-    }
+    export const undefined = (options: ITransformOptions): boolean =>
+        options.undefined !== false;
 }

package/src/programmers/helpers/PruneJoiner.ts

@@ -28,7 +28,7 @@ export namespace PruneJoiner {
 
     export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
         ts.factory.createCallExpression(
-            IdentifierFactory.join(input, "forEach"),
+            IdentifierFactory.join(input)("forEach"),
             undefined,
             [arrow],
         );