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

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],
         );

package/src/programmers/helpers/StringifyJoinder.ts

@@ -61,16 +61,16 @@ export namespace StringifyJoiner {
             ]);
         };
 
-    export function array(
+    export const array = (
         input: ts.Expression,
         arrow: ts.ArrowFunction,
-    ): ts.Expression {
-        return TemplateFactory.generate([
+    ): ts.Expression =>
+        TemplateFactory.generate([
             ts.factory.createStringLiteral(`[`),
             ts.factory.createCallExpression(
                 ts.factory.createPropertyAccessExpression(
                     ts.factory.createCallExpression(
-                        IdentifierFactory.join(input, "map"),
+                        IdentifierFactory.join(input)("map"),
                         undefined,
                         [arrow],
                     ),
@@ -81,12 +81,11 @@ export namespace StringifyJoiner {
             ),
             ts.factory.createStringLiteral(`]`),
         ]);
-    }
 
-    export function tuple(
+    export const tuple = (
         children: ts.Expression[],
         rest: ts.Expression | null,
-    ): ts.Expression {
+    ): ts.Expression => {
         if (children.length === 0) return ts.factory.createStringLiteral("[]");
         if (
             rest === null &&
@@ -110,5 +109,5 @@ export namespace StringifyJoiner {
 
         elements.push(ts.factory.createStringLiteral(`]`));
         return TemplateFactory.generate(elements);
-    }
+    };
 }

package/src/programmers/helpers/StringifyPredicator.ts

@@ -1,18 +1,12 @@
 import { Metadata } from "../../metadata/Metadata";
 
 export namespace StringifyPredicator {
-    export function require_escape(value: string): boolean {
-        return value
-            .split("")
-            .some((ch) => ESCAPED.some((escaped) => escaped === ch));
-    }
+    export const require_escape = (value: string): boolean =>
+        value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
 
-    export function undefindable(meta: Metadata): boolean {
-        return (
-            meta.required === false ||
-            (meta.resolved !== null && meta.resolved.required === false)
-        );
-    }
+    export const undefindable = (meta: Metadata): boolean =>
+        meta.required === false ||
+        (meta.resolved !== null && meta.resolved.required === false);
 
     const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
 }

package/src/programmers/helpers/UnionExplorer.ts

@@ -75,10 +75,8 @@ export namespace UnionExplorer {
                 .filter((spec) => spec.property.key.getSoleLiteral() !== null)
                 .map((spec) => {
                     const key: string = spec.property.key.getSoleLiteral()!;
-                    const accessor: ts.Expression = IdentifierFactory.join(
-                        input,
-                        key,
-                    );
+                    const accessor: ts.Expression =
+                        IdentifierFactory.join(input)(key);
                     const pred: ts.Expression = spec.neighbour
                         ? config.objector.checker(
                               accessor,
@@ -161,7 +159,7 @@ export namespace UnionExplorer {
 
     export const array = (props: array.IProps) =>
         check_union_array_like<Metadata>({
-            size: (input) => IdentifierFactory.join(input, "length"),
+            size: (input) => IdentifierFactory.join(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
@@ -173,7 +171,7 @@ export namespace UnionExplorer {
 
     export const array_or_tuple = (props: array_or_tuple.IProps) =>
         check_union_array_like<Metadata | Metadata[]>({
-            size: (input) => IdentifierFactory.join(input, "length"),
+            size: (input) => IdentifierFactory.join(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
@@ -190,23 +188,21 @@ export namespace UnionExplorer {
 
     export const set = (props: set.IProps) =>
         check_union_array_like<Metadata>({
-            size: (input) => IdentifierFactory.join(input, "size"),
+            size: (input) => IdentifierFactory.join(input)("size"),
             front: (input) =>
                 IdentifierFactory.join(
                     ts.factory.createCallExpression(
                         IdentifierFactory.join(
                             ts.factory.createCallExpression(
-                                IdentifierFactory.join(input, "values"),
+                                IdentifierFactory.join(input)("values"),
                                 undefined,
                                 undefined,
                             ),
-                            "next",
-                        ),
+                        )("next"),
                         undefined,
                         undefined,
                     ),
-                    "value",
-                ),
+                )("value"),
             array: (input) =>
                 ts.factory.createArrayLiteralExpression(
                     [ts.factory.createSpreadElement(input)],
@@ -220,23 +216,21 @@ export namespace UnionExplorer {
 
     export const map = (props: map.IProps) =>
         check_union_array_like<[Metadata, Metadata]>({
-            size: (input) => IdentifierFactory.join(input, "size"),
+            size: (input) => IdentifierFactory.join(input)("size"),
             front: (input) =>
                 IdentifierFactory.join(
                     ts.factory.createCallExpression(
                         IdentifierFactory.join(
                             ts.factory.createCallExpression(
-                                IdentifierFactory.join(input, "entries"),
+                                IdentifierFactory.join(input)("entries"),
                                 undefined,
                                 undefined,
                             ),
-                            "next",
-                        ),
+                        )("next"),
                         undefined,
                         undefined,
                     ),
-                    "value",
-                ),
+                )("value"),
             array: (input) =>
                 ts.factory.createArrayLiteralExpression(
                     [ts.factory.createSpreadElement(input)],

package/src/programmers/helpers/UnionPredicator.ts

@@ -13,14 +13,14 @@ export namespace UnionPredicator {
         neighbour: boolean;
     }
 
-    export function object(targets: MetadataObject[]): Array<ISpecialized> {
+    export const object = (targets: MetadataObject[]): Array<ISpecialized> => {
         // PROPERTY MATRIX
         const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
         for (const obj of targets)
             for (const prop of obj.properties) {
                 const key: string | null = prop.key.getSoleLiteral();
                 if (key !== null)
-                    MapUtil.take(matrix, key, () =>
+                    MapUtil.take(matrix)(key, () =>
                         ArrayUtil.repeat(targets.length, () => null),
                     );
             }
@@ -72,7 +72,7 @@ export namespace UnionPredicator {
             });
         });
         return output;
-    }
+    };
 }
 
 interface ISpecializedProperty {

package/src/programmers/internal/application_array.ts

@@ -12,25 +12,24 @@ export const application_array =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (tuple?: IJsonSchema.ITuple) =>
-    (
-        metadata: Metadata,
-        nullable: boolean,
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.IArray => {
+    (metadata: Metadata) =>
+    (props: {
+        nullable: boolean;
+        attribute: IJsonSchema.IAttribute;
+    }): IJsonSchema.IArray => {
         // SCHEMA
         const output: IJsonSchema.IArray = {
             type: "array",
-            items: application_schema(options)(components)(false)(
-                metadata,
-                attribute,
+            items: application_schema(options)(false)(components)(metadata)(
+                props.attribute,
             ),
-            nullable,
+            nullable: props.nullable,
             "x-typia-tuple": tuple,
-            ...attribute,
+            ...props.attribute,
         };
 
         // RANGE
-        for (const tag of attribute["x-typia-metaTags"] || [])
+        for (const tag of props.attribute["x-typia-metaTags"] || [])
             if (tag.kind === "minItems") output.minItems = tag.value;
             else if (tag.kind === "maxItems") output.maxItems = tag.value;
         return output;

package/src/programmers/internal/application_boolean.ts

@@ -4,14 +4,14 @@ import { application_default } from "./application_default";
 /**
  * @internal
  */
-export const application_boolean = (
-    nullable: boolean,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IBoolean => ({
+export const application_boolean = (props: {
+    nullable: boolean;
+    attribute: IJsonSchema.IAttribute;
+}): IJsonSchema.IBoolean => ({
     type: "boolean",
-    nullable,
-    ...attribute,
-    default: application_default(attribute)(
+    nullable: props.nullable,
+    ...props.attribute,
+    default: application_default(props.attribute)(
         (def) => def === "true" || def === "false",
     )((str) => Boolean(str)),
 });

package/src/programmers/internal/application_constant.ts

@@ -6,24 +6,25 @@ import { application_default } from "./application_default";
 /**
  * @internal
  */
-export const application_constant = (
-    constant: MetadataConstant,
-    nullable: boolean,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IEnumeration<any> => ({
-    type: constant.type,
-    enum: constant.values as any,
-    nullable,
-    ...attribute,
-    default: application_default(attribute)((def) =>
-        constant.values.some((v) => v.toString() === def),
-    )(
-        constant.type === "string"
-            ? (str) => str
-            : constant.type === "number"
-            ? (str) => Number(str)
-            : constant.type === "boolean"
-            ? (str) => Boolean(str)
-            : (str) => BigInt(str) as any,
-    ),
-});
+export const application_constant =
+    (constant: MetadataConstant) =>
+    (props: {
+        nullable: boolean;
+        attribute: IJsonSchema.IAttribute;
+    }): IJsonSchema.IEnumeration<any> => ({
+        type: constant.type,
+        enum: constant.values as any,
+        nullable: props.nullable,
+        ...props.attribute,
+        default: application_default(props.attribute)((def) =>
+            constant.values.some((v) => v.toString() === def),
+        )(
+            constant.type === "string"
+                ? (str) => str
+                : constant.type === "number"
+                ? (str) => Number(str)
+                : constant.type === "boolean"
+                ? (str) => Boolean(str)
+                : (str) => BigInt(str) as any,
+        ),
+    });

package/src/programmers/internal/application_default_string.ts

@@ -7,7 +7,8 @@ import { application_default } from "./application_default";
  * @internal
  */
 export const application_default_string =
-    (meta: Metadata, attribute: IJsonSchema.IAttribute) =>
+    (meta: Metadata) =>
+    (attribute: IJsonSchema.IAttribute) =>
     (schema: IJsonSchema.IString) =>
         application_default(attribute)((str) => {
             const conditions: boolean[] = [];

package/src/programmers/internal/application_native.ts

@@ -10,11 +10,11 @@ export const application_native =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
     (name: string) =>
-    (
-        nullable: boolean,
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.IReference => {
-        const key: string = name + (nullable ? ".Nullable" : "");
+    (props: {
+        nullable: boolean;
+        attribute: IJsonSchema.IAttribute;
+    }): IJsonSchema.IReference => {
+        const key: string = name + (props.nullable ? ".Nullable" : "");
         if (components.schemas[key] === undefined)
             components.schemas[key] = {
                 type: "object",
@@ -23,10 +23,10 @@ export const application_native =
                         ? options.prefix + "/" + key
                         : undefined,
                 properties: {},
-                nullable,
+                nullable: props.nullable,
             };
         return {
             $ref: `#/components/schemas/${name}`,
-            ...attribute,
+            ...props.attribute,
         };
     };

package/src/programmers/internal/application_number.ts

@@ -4,16 +4,16 @@ import { application_default } from "./application_default";
 /**
  * @internal
  */
-export const application_number = (
-    nullable: boolean,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.INumber | IJsonSchema.IInteger => {
+export const application_number = (props: {
+    nullable: boolean;
+    attribute: IJsonSchema.IAttribute;
+}): IJsonSchema.INumber | IJsonSchema.IInteger => {
     const output: IJsonSchema.INumber | IJsonSchema.IInteger = {
         type: "number" as "number" | "integer",
-        nullable,
-        ...attribute,
+        nullable: props.nullable,
+        ...props.attribute,
     };
-    for (const tag of attribute["x-typia-metaTags"] || []) {
+    for (const tag of props.attribute["x-typia-metaTags"] || []) {
         // CHECK TYPE
         if (
             tag.kind === "type" &&
@@ -37,7 +37,7 @@ export const application_number = (
     // WHEN UNSIGNED INT
     if (
         output.type === "integer" &&
-        (attribute["x-typia-metaTags"] || []).find(
+        (props.attribute["x-typia-metaTags"] || []).find(
             (tag) => tag.kind === "type" && tag.value === "uint",
         )
     )
@@ -52,7 +52,7 @@ export const application_number = (
         }
 
     // DEFAULT CONFIGURATION
-    output.default = application_default(attribute)((str) => {
+    output.default = application_default(props.attribute)((str) => {
         const value: number = Number(str);
         const conditions: boolean[] = [!Number.isNaN(value)];
         if (output.minimum !== undefined)

package/src/programmers/internal/application_object.ts

@@ -18,10 +18,11 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 export const application_object =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (key: string, obj: MetadataObject, nullable: boolean): void => {
+    (obj: MetadataObject) =>
+    (props: { key: string; nullable: boolean }): void => {
         // TEMPORARY ASSIGNMENT
-        if (components.schemas[key] !== undefined) return;
-        components.schemas[key] = {} as any;
+        if (components.schemas[props.key] !== undefined) return;
+        components.schemas[props.key] = {} as any;
 
         // ITERATE PROPERTIES
         const properties: Record<string, any> = {};
@@ -42,8 +43,8 @@ export const application_object =
 
             const key: string | null = property.key.getSoleLiteral();
             const schema: IJsonSchema | null = application_schema(options)(
-                components,
-            )(true)(property.value, {
+                true,
+            )(components)(property.value)({
                 deprecated:
                     !!property.jsDocTags.find(
                         (tag) => tag.name === "deprecated",
@@ -52,7 +53,7 @@ export const application_object =
                     const info: IJsDocTagInfo | undefined =
                         property.jsDocTags.find((tag) => tag.name === "title");
                     return info?.text?.length
-                        ? CommentFactory.generate(info.text)
+                        ? CommentFactory.string(info.text)
                         : undefined;
                 })(),
                 description: property.description,
@@ -97,13 +98,13 @@ export const application_object =
         const schema: IJsonComponents.IObject = {
             $id:
                 options.purpose === "ajv"
-                    ? options.prefix + "/" + key
+                    ? options.prefix + "/" + props.key
                     : undefined,
             $recursiveAnchor:
                 (options.purpose === "ajv" && obj.recursive) || undefined,
             type: "object",
             properties,
-            nullable,
+            nullable: props.nullable,
             required: required.length ? required : undefined,
             description: obj.description,
             "x-typia-jsDocTags": obj.jsDocTags,
@@ -118,7 +119,7 @@ export const application_object =
                           join(options)(components)(extraMeta),
                   }),
         };
-        components.schemas[key] = schema;
+        components.schemas[props.key] = schema;
     };
 
 const join =
@@ -141,7 +142,7 @@ const join =
             .map((tuple) => tuple[0])
             .reduce((x, y) => Metadata.merge(x, y));
         return (
-            application_schema(options)(components)(true)(meta, {
+            application_schema(options)(true)(components)(meta)({
                 "x-typia-required": false,
             }) ?? undefined
         );