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

package/src/programmers/IsCloneProgrammer.ts

@@ -10,8 +10,17 @@ import { CloneProgrammer } from "./CloneProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 
 export namespace IsCloneProgrammer {
+    /**
+     * @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,
@@ -26,7 +35,7 @@ export namespace IsCloneProgrammer {
                     ts.factory.createTypeReferenceNode(
                         `typia.Primitive<${
                             name ??
-                            TypeFactory.getFullName(project.checker, type)
+                            TypeFactory.getFullName(project.checker)(type)
                         }>`,
                     ),
                     ts.factory.createLiteralTypeNode(ts.factory.createNull()),
@@ -35,21 +44,18 @@ export namespace IsCloneProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(project, modulo)(type, name),
+                        IsProgrammer.write(project)(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "clone",
-                        CloneProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        CloneProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(type, name),
                     ),
                     ts.factory.createIfStatement(
                         ts.factory.createPrefixUnaryExpression(

package/src/programmers/IsParseProgrammer.ts

@@ -9,8 +9,17 @@ import { IProject } from "../transformers/IProject";
 import { IsProgrammer } from "./IsProgrammer";
 
 export namespace IsParseProgrammer {
+    /**
+     * @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,
@@ -23,24 +32,21 @@ export namespace IsParseProgrammer {
                 ],
                 ts.factory.createTypeReferenceNode(
                     `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker, type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        IsProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(false)(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/IsProgrammer.ts

@@ -16,7 +16,7 @@ import { check_object } from "./internal/check_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
 export namespace IsProgrammer {
-    export const CONFIG =
+    export const configure =
         (options?: Partial<CONFIG.IOptions>) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
             functors: "$io",
@@ -66,7 +66,7 @@ export namespace IsProgrammer {
                     })(importer),
                 array: (input, arrow) =>
                     ts.factory.createCallExpression(
-                        IdentifierFactory.join(input, "every"),
+                        IdentifierFactory.join(input)("every"),
                         undefined,
                         [arrow],
                     ),
@@ -87,120 +87,126 @@ export namespace IsProgrammer {
     }
 
     /* -----------------------------------------------------------
-        GENERATORS
+        WRITERS
     ----------------------------------------------------------- */
-    export function generate(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        equals: boolean = false,
-    ) {
-        const importer: FunctionImporter = new FunctionImporter();
-
-        // CONFIGURATION
-        const config = CONFIG({
-            object: check_object({
-                equals,
-                undefined: OptionPredicator.undefined(project.options),
-                assert: true,
-                reduce: ts.factory.createLogicalAnd,
-                positive: ts.factory.createTrue(),
-                superfluous: () => ts.factory.createFalse(),
-            })(importer),
-            numeric: OptionPredicator.numeric(project.options),
-        })(importer);
-        config.trace = equals;
-
-        config.decoder = (input, target, explore, tags, jsDocTags) => {
-            if (
-                target.size() === 1 &&
-                target.objects.length === 1 &&
-                target.required === true &&
-                target.nullable === false
-            ) {
-                // ONLY WHEN OBJECT WITH SOME ATOMIC PROPERTIES
-                const obj: MetadataObject = target.objects[0]!;
+    /**
+     * @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) => {
+            const importer: FunctionImporter = new FunctionImporter();
+
+            // CONFIGURATION
+            const config: CheckerProgrammer.IConfig = {
+                ...configure({
+                    object: check_object({
+                        equals,
+                        undefined: OptionPredicator.undefined(project.options),
+                        assert: true,
+                        reduce: ts.factory.createLogicalAnd,
+                        positive: ts.factory.createTrue(),
+                        superfluous: () => ts.factory.createFalse(),
+                    })(importer),
+                    numeric: OptionPredicator.numeric(project.options),
+                })(importer),
+                trace: equals,
+                addition: () => importer.declare(modulo),
+            };
+
+            config.decoder = (input, target, explore, tags, jsDocTags) => {
                 if (
-                    obj._Is_simple() &&
-                    (equals === false ||
-                        OptionPredicator.undefined(project.options) === false)
-                )
-                    return ts.factory.createLogicalAnd(
-                        ExpressionFactory.isObject(input, {
-                            checkNull: true,
-                            checkArray: false,
-                        }),
-                        config.joiner.object(
-                            input,
-                            feature_object_entries(config as any)(importer)(
-                                obj,
-                            )(input),
-                        ),
-                    );
-            }
-            return CheckerProgrammer.decode(project, config, importer)(
-                input,
-                target,
-                explore,
-                tags,
-                jsDocTags,
-            );
+                    target.size() === 1 &&
+                    target.objects.length === 1 &&
+                    target.required === true &&
+                    target.nullable === false
+                ) {
+                    // ONLY WHEN OBJECT WITH SOME ATOMIC PROPERTIES
+                    const obj: MetadataObject = target.objects[0]!;
+                    if (
+                        obj._Is_simple() &&
+                        (equals === false ||
+                            OptionPredicator.undefined(project.options) ===
+                                false)
+                    )
+                        return ts.factory.createLogicalAnd(
+                            ExpressionFactory.isObject({
+                                checkNull: true,
+                                checkArray: false,
+                            })(input),
+                            config.joiner.object(
+                                input,
+                                feature_object_entries(config as any)(importer)(
+                                    obj,
+                                )(input),
+                            ),
+                        );
+                }
+                return CheckerProgrammer.decode(project)(config)(importer)(
+                    input,
+                    target,
+                    explore,
+                    tags,
+                    jsDocTags,
+                );
+            };
+
+            // GENERATE CHECKER
+            return CheckerProgrammer.write(project)(config)(importer);
         };
 
-        // GENERATE CHECKER
-        return CheckerProgrammer.generate(project, config, importer, () =>
-            importer.declare(modulo),
-        );
-    }
-
-    export const generate_functors = (
-        project: IProject,
-        importer: FunctionImporter,
-    ) =>
-        CheckerProgrammer.generate_functors(
-            project,
-            CONFIG()(importer),
-            importer,
-        );
+    export const write_functors =
+        (project: IProject) => (importer: FunctionImporter) =>
+            CheckerProgrammer.write_functors(project)(configure()(importer))(
+                importer,
+            );
 
-    export const generate_unioners = (
-        project: IProject,
-        importer: FunctionImporter,
-    ) =>
-        CheckerProgrammer.generate_unioners(
-            project,
-            CONFIG()(importer),
-            importer,
-        );
+    export const write_unioners =
+        (project: IProject) => (importer: FunctionImporter) =>
+            CheckerProgrammer.write_unioners(
+                project,
+                configure()(importer),
+                importer,
+            );
 
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     export const decode = (project: IProject, importer: FunctionImporter) =>
-        CheckerProgrammer.decode(project, CONFIG()(importer), importer);
+        CheckerProgrammer.decode(project)(configure()(importer))(importer);
 
     export const decode_object = (importer: FunctionImporter) =>
-        CheckerProgrammer.decode_object(CONFIG()(importer))(importer);
-
-    export function decode_to_json(
-        input: ts.Expression,
-        checkNull: boolean,
-    ): ts.Expression {
-        return ts.factory.createLogicalAnd(
-            ExpressionFactory.isObject(input, {
-                checkArray: false,
-                checkNull,
-            }),
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("function"),
-                ValueFactory.TYPEOF(IdentifierFactory.join(input, "toJSON")),
-            ),
-        );
-    }
+        CheckerProgrammer.decode_object(configure()(importer))(importer);
+
+    export const decode_to_json =
+        (checkNull: boolean) =>
+        (input: ts.Expression): ts.Expression =>
+            ts.factory.createLogicalAnd(
+                ExpressionFactory.isObject({
+                    checkArray: false,
+                    checkNull,
+                })(input),
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("function"),
+                    ValueFactory.TYPEOF(
+                        IdentifierFactory.join(input)("toJSON"),
+                    ),
+                ),
+            );
 
-    export function decode_functional(input: ts.Expression) {
-        return ts.factory.createStrictEquality(
+    export const decode_functional = (input: ts.Expression) =>
+        ts.factory.createStrictEquality(
             ts.factory.createStringLiteral("function"),
             ValueFactory.TYPEOF(input),
         );
-    }
 }

package/src/programmers/IsPruneProgrammer.ts

@@ -10,8 +10,17 @@ import { IsProgrammer } from "./IsProgrammer";
 import { PruneProgrammer } from "./PruneProgrammer";
 
 export namespace IsPruneProgrammer {
+    /**
+     * @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,
@@ -26,28 +35,25 @@ export namespace IsPruneProgrammer {
                     undefined,
                     "input",
                     ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker, type),
+                        name ?? TypeFactory.getFullName(project.checker)(type),
                     ),
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(project, modulo)(type, name),
+                        IsProgrammer.write(project)(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),
                     ),
                     ts.factory.createIfStatement(
                         ts.factory.createPrefixUnaryExpression(

package/src/programmers/IsStringifyProgrammer.ts

@@ -10,8 +10,17 @@ import { IsProgrammer } from "./IsProgrammer";
 import { StringifyProgrammer } from "./StringifyProgrammer";
 
 export namespace IsStringifyProgrammer {
+    /**
+     * @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 IsStringifyProgrammer {
                         "input",
                         ts.factory.createTypeReferenceNode(
                             name ??
-                                TypeFactory.getFullName(project.checker, type),
+                                TypeFactory.getFullName(project.checker)(type),
                         ),
                     ),
                 ],
@@ -33,31 +42,25 @@ export namespace IsStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: true,
-                                },
+                        IsProgrammer.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),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createConditionalExpression(

package/src/programmers/LiteralsProgrammer.ts

@@ -1,65 +1,65 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../factories/MetadataCollection";
-import { MetadataFactory } from "../factories/MetadataFactory";
-
-import { Metadata } from "../metadata/Metadata";
-
-import { IProject } from "../transformers/IProject";
-
-import { Atomic } from "../typings/Atomic";
-
-import { ArrayUtil } from "../utils/ArrayUtil";
-
-export namespace LiteralsProgrammer {
-    export const generate = (project: IProject) => (type: ts.Type) => {
-        const meta: Metadata = MetadataFactory.generate(
-            project.checker,
-            new MetadataCollection(),
-            type,
-            {
-                resolve: true,
-                constant: true,
-                validate: (meta) => {
-                    const length: number =
-                        meta.constants
-                            .map((c) => c.values.length)
-                            .reduce((a, b) => a + b, 0) +
-                        meta.atomics.filter((type) => type === "boolean")
-                            .length;
-                    if (0 === length) throw new Error(ErrorMessages.NO);
-                    else if (meta.size() !== length)
-                        throw new Error(ErrorMessages.ONLY);
-                },
-            },
-        );
-        const values: Set<Atomic.Type> = new Set([
-            ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
-            ...(meta.atomics.filter((type) => type === "boolean").length
-                ? [true, false]
-                : []),
-        ]);
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                [...values].map((v) =>
-                    typeof v === "boolean"
-                        ? v
-                            ? ts.factory.createTrue()
-                            : ts.factory.createFalse()
-                        : typeof v === "number"
-                        ? ts.factory.createNumericLiteral(v)
-                        : typeof v === "bigint"
-                        ? ts.factory.createBigIntLiteral(v.toString())
-                        : ts.factory.createStringLiteral(v),
-                ),
-                true,
-            ),
-            ts.factory.createTypeReferenceNode("const"),
-        );
-    };
-}
-
-enum ErrorMessages {
-    NO = "Error on typia.literals(): no literal type found.",
-    ONLY = "Error on typia.literals(): only literal type allowed.",
-}
+import ts from "typescript";
+
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { IProject } from "../transformers/IProject";
+
+import { Atomic } from "../typings/Atomic";
+
+import { ArrayUtil } from "../utils/ArrayUtil";
+
+export namespace LiteralsProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate = (project: IProject) => (type: ts.Type) =>
+        write(project)(type);
+
+    export const write = (project: IProject) => (type: ts.Type) => {
+        const meta: Metadata = MetadataFactory.analyze(project.checker)({
+            resolve: true,
+            constant: true,
+            validate: (meta) => {
+                const length: number =
+                    meta.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    meta.atomics.filter((type) => type === "boolean").length;
+                if (0 === length) throw new Error(ErrorMessages.NO);
+                else if (meta.size() !== length)
+                    throw new Error(ErrorMessages.ONLY);
+            },
+        })(new MetadataCollection())(type);
+        const values: Set<Atomic.Type> = new Set([
+            ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
+            ...(meta.atomics.filter((type) => type === "boolean").length
+                ? [true, false]
+                : []),
+        ]);
+        return ts.factory.createAsExpression(
+            ts.factory.createArrayLiteralExpression(
+                [...values].map((v) =>
+                    typeof v === "boolean"
+                        ? v
+                            ? ts.factory.createTrue()
+                            : ts.factory.createFalse()
+                        : typeof v === "number"
+                        ? ts.factory.createNumericLiteral(v)
+                        : typeof v === "bigint"
+                        ? ts.factory.createBigIntLiteral(v.toString())
+                        : ts.factory.createStringLiteral(v),
+                ),
+                true,
+            ),
+            ts.factory.createTypeReferenceNode("const"),
+        );
+    };
+}
+
+enum ErrorMessages {
+    NO = "Error on typia.literals(): no literal type found.",
+    ONLY = "Error on typia.literals(): only literal type allowed.",
+}