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

package/src/programmers/internal/application_schema.ts

@@ -19,10 +19,10 @@ import { application_tuple } from "./application_tuple";
  */
 export const application_schema =
     (options: ApplicationProgrammer.IOptions) =>
-    (components: IJsonComponents) =>
     <BlockNever extends boolean>(blockNever: BlockNever) =>
+    (components: IJsonComponents) =>
+    (meta: Metadata) =>
     (
-        meta: Metadata,
         attribute: IJsonSchema.IAttribute,
     ): BlockNever extends true ? IJsonSchema | null : IJsonSchema => {
         // VULNERABLE CASE
@@ -37,15 +37,15 @@ export const application_schema =
 
         // toJSON() METHOD
         if (meta.resolved !== null) {
-            const resolved = application_schema(options)(components)(
-                blockNever,
-            )(meta.resolved, attribute);
+            const resolved = application_schema(options)(blockNever)(
+                components,
+            )(meta.resolved)(attribute);
             if (resolved !== null) union.push(resolved);
         }
 
         // ATOMIC TYPES
         if (meta.templates.length && AtomicPredicator.template(meta))
-            union.push(application_templates(meta, attribute));
+            union.push(application_templates(meta)(attribute));
         for (const constant of meta.constants)
             if (constant.type === "bigint") throw new Error(NO_BIGINT);
             else if (
@@ -55,7 +55,10 @@ export const application_schema =
                 continue;
             else
                 union.push(
-                    application_constant(constant, meta.nullable, attribute),
+                    application_constant(constant)({
+                        nullable: meta.nullable,
+                        attribute,
+                    }),
                 );
         for (const type of meta.atomics)
             if (type === "bigint") throw new Error(NO_BIGINT);
@@ -65,25 +68,33 @@ export const application_schema =
                     type === "string"
                         ? application_string(meta, attribute)
                         : type === "boolean"
-                        ? application_boolean(meta.nullable, attribute)
-                        : application_number(meta.nullable, attribute),
+                        ? application_boolean({
+                              nullable: meta.nullable,
+                              attribute,
+                          })
+                        : application_number({
+                              nullable: meta.nullable,
+                              attribute,
+                          }),
                 );
 
         // ARRAY
         for (const schema of meta.arrays.values())
             union.push(
-                application_array(options)(components)()(
-                    schema,
-                    meta.nullable,
+                application_array(options)(components)()(schema)({
+                    nullable: meta.nullable,
                     attribute,
-                ),
+                }),
             );
 
         // TUPLE
         for (const items of meta.tuples) {
             const tuple: IJsonSchema.ITuple = application_tuple(options)(
                 components,
-            )(items, meta.nullable, attribute);
+            )(items)({
+                nullable: meta.nullable,
+                attribute,
+            });
             if (options.purpose === "swagger" && items.length === 0)
                 throw new Error(
                     "Error on typia.application(): swagger does not support zero length tuple type.",
@@ -99,11 +110,10 @@ export const application_schema =
                     Metadata.merge(x, y),
                 );
                 union.push(
-                    application_array(options)(components)(tuple)(
-                        merged,
-                        merged?.nullable || false,
+                    application_array(options)(components)(tuple)(merged)({
+                        nullable: merged?.nullable ?? false,
                         attribute,
-                    ),
+                    }),
                 );
             }
         }
@@ -115,35 +125,44 @@ export const application_schema =
                     native === "String"
                         ? application_string(meta, attribute)
                         : native === "Boolean"
-                        ? application_boolean(meta.nullable, attribute)
-                        : application_number(meta.nullable, attribute),
+                        ? application_boolean({
+                              nullable: meta.nullable,
+                              attribute,
+                          })
+                        : application_number({
+                              nullable: meta.nullable,
+                              attribute,
+                          }),
                 );
             else
                 union.push(
-                    application_native(options)(components)(native)(
-                        meta.nullable,
+                    application_native(options)(components)(native)({
+                        nullable: meta.nullable,
                         attribute,
-                    ),
+                    }),
                 );
         if (meta.sets.length)
             union.push(
-                application_native(options)(components)(`Set`)(
-                    meta.nullable,
+                application_native(options)(components)(`Set`)({
+                    nullable: meta.nullable,
                     attribute,
-                ),
+                }),
             );
         if (meta.maps.length)
             union.push(
-                application_native(options)(components)(`Map`)(
-                    meta.nullable,
+                application_native(options)(components)(`Map`)({
+                    nullable: meta.nullable,
                     attribute,
-                ),
+                }),
             );
 
         // OBJECT
         for (const obj of meta.objects) {
             const key: string = obj.name + (meta.nullable ? ".Nullable" : "");
-            application_object(options)(components)(key, obj, meta.nullable);
+            application_object(options)(components)(obj)({
+                key,
+                nullable: meta.nullable,
+            });
             union.push(
                 (options.purpose === "ajv" && obj.recursive
                     ? recursive

package/src/programmers/internal/application_string.ts

@@ -35,7 +35,7 @@ export const application_string = (
     }
 
     // DEFAULT CONFIGURATION
-    output.default = application_default_string(meta, attribute)(output);
+    output.default = application_default_string(meta)(attribute)(output);
 
     // RETURNS
     return output;

package/src/programmers/internal/application_templates.ts

@@ -7,21 +7,20 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 /**
  * @internal
  */
-export const application_templates = (
-    meta: Metadata,
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.IString => {
-    // CONSTRUCT PATTERN
-    const output: IJsonSchema.IString = {
-        type: "string",
-        nullable: meta.nullable,
-        ...attribute,
-    };
-    output.pattern = metadata_to_pattern(true)(meta);
+export const application_templates =
+    (meta: Metadata) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IString => {
+        // CONSTRUCT PATTERN
+        const output: IJsonSchema.IString = {
+            type: "string",
+            nullable: meta.nullable,
+            ...attribute,
+        };
+        output.pattern = metadata_to_pattern(true)(meta);
 
-    // DEFAULT VALUE
-    output.default = application_default_string(meta, attribute)(output);
+        // DEFAULT VALUE
+        output.default = application_default_string(meta)(attribute)(output);
 
-    // RETURNS
-    return output;
-};
+        // RETURNS
+        return output;
+    };

package/src/programmers/internal/application_tuple.ts

@@ -11,19 +11,19 @@ import { application_schema } from "./application_schema";
 export const application_tuple =
     (options: ApplicationProgrammer.IOptions) =>
     (components: IJsonComponents) =>
-    (
-        items: Array<Metadata>,
-        nullable: boolean,
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.ITuple => ({
+    (items: Array<Metadata>) =>
+    (props: {
+        nullable: boolean;
+        attribute: IJsonSchema.IAttribute;
+    }): IJsonSchema.ITuple => ({
         type: "array",
         items: items.map((meta, i) =>
-            application_schema(options)(components)(false)(meta.rest ?? meta, {
-                ...attribute,
+            application_schema(options)(false)(components)(meta.rest ?? meta)({
+                ...props.attribute,
                 "x-typia-rest":
                     i === items.length - 1 ? meta.rest !== null : undefined,
             }),
         ),
-        nullable,
-        ...attribute,
+        nullable: props.nullable,
+        ...props.attribute,
     });

package/src/programmers/internal/check_array.ts

@@ -22,7 +22,7 @@ export const check_array =
         expression: ExpressionFactory.isArray(input),
         tags: [
             ...check_array_length(metaTags)(
-                IdentifierFactory.join(input, "length"),
+                IdentifierFactory.join(input)("length"),
             ),
             ...check_custom("array", "Array")(importer)(jsDocTags)(input),
             // check custom array for legacy (3.7.0)

package/src/programmers/internal/check_custom.ts

@@ -1,33 +1,31 @@
-import ts from "typescript";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { get_comment_tags } from "./get_comment_tags";
-
-/**
- * @internal
- */
-export const check_custom =
-    (type: string, alias?: string) =>
-    (importer: FunctionImporter) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
-    (input: ts.Expression): ICheckEntry.ITag[] =>
-        get_comment_tags(true)(jsDocTags).map((tag) => {
-            return {
-                expected: `${alias ?? type} (@${tag.name}${
-                    tag.value?.length ? ` ${tag.value}` : ""
-                })`,
-                expression: ts.factory.createCallExpression(
-                    importer.use("is_custom"),
-                    undefined,
-                    [
-                        ts.factory.createStringLiteral(tag.name),
-                        ts.factory.createStringLiteral(type),
-                        ts.factory.createStringLiteral(tag.value ?? ""),
-                        input,
-                    ],
-                ),
-            };
-        });
+import ts from "typescript";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { get_comment_tags } from "./get_comment_tags";
+
+/**
+ * @internal
+ */
+export const check_custom =
+    (type: string, alias?: string) =>
+    (importer: FunctionImporter) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] =>
+        get_comment_tags(true)(jsDocTags).map((tag) => ({
+            expected: `${alias ?? type} (@${tag.name}${
+                tag.value?.length ? ` ${tag.value}` : ""
+            })`,
+            expression: ts.factory.createCallExpression(
+                importer.use("is_custom"),
+                undefined,
+                [
+                    ts.factory.createStringLiteral(tag.name),
+                    ts.factory.createStringLiteral(type),
+                    ts.factory.createStringLiteral(tag.value ?? ""),
+                    input,
+                ],
+            ),
+        }));