typia 4.3.2-dev.20230821 → 4.3.3-dev.20230825

package/src/programmers/internal/application_tuple.ts

@@ -1,57 +1,57 @@
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataTuple } from "../../metadata/MetadataTuple";
-import { IJsonComponents } from "../../schemas/IJsonComponents";
-import { IJsonSchema } from "../../schemas/IJsonSchema";
-
-import { ApplicationProgrammer } from "../ApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-/**
- * @internal
- */
-export const application_tuple =
-    (options: ApplicationProgrammer.IOptions) =>
-    (components: IJsonComponents) =>
-    (tuple: MetadataTuple) =>
-    (
-        attribute: IJsonSchema.IAttribute,
-    ): IJsonSchema.ITuple | IJsonSchema.IArray => {
-        const schema: IJsonSchema.ITuple = {
-            type: "array",
-            items: tuple.elements.map((meta, i) =>
-                application_schema(options)(false)(components)(
-                    meta.rest ?? meta,
-                )({
-                    ...attribute,
-                    "x-typia-rest":
-                        i === tuple.elements.length - 1 && meta.rest !== null,
-                    "x-typia-required": meta.required,
-                    "x-typia-optional": meta.optional,
-                }),
-            ),
-            ...attribute,
-            minItems: !!tuple.elements.at(-1)?.rest
-                ? tuple.elements.length - 1
-                : tuple.elements.filter((x) => !x.optional).length,
-            maxItems: !!tuple.elements.at(-1)?.rest
-                ? undefined
-                : tuple.elements.length,
-        };
-        if (options.purpose === "ajv")
-            if (tuple.elements.length === 0) return schema;
-            else if (!tuple.elements.at(-1)?.rest) return schema;
-
-        const wrapper: IJsonSchema.IArray = {
-            ...schema,
-            items: application_schema(options)(false)(components)(
-                tuple.elements.reduce(
-                    (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
-                    Metadata.initialize(),
-                ),
-            )(tuple.recursive ? {} : attribute),
-            "x-typia-tuple": schema,
-            minItems: schema.minItems,
-            maxItems: schema.maxItems,
-        };
-        return wrapper;
-    };
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataTuple } from "../../metadata/MetadataTuple";
+import { IJsonComponents } from "../../schemas/IJsonComponents";
+import { IJsonSchema } from "../../schemas/IJsonSchema";
+
+import { ApplicationProgrammer } from "../ApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+/**
+ * @internal
+ */
+export const application_tuple =
+    (options: ApplicationProgrammer.IOptions) =>
+    (components: IJsonComponents) =>
+    (tuple: MetadataTuple) =>
+    (
+        attribute: IJsonSchema.IAttribute,
+    ): IJsonSchema.ITuple | IJsonSchema.IArray => {
+        const schema: IJsonSchema.ITuple = {
+            type: "array",
+            items: tuple.elements.map((meta, i) =>
+                application_schema(options)(false)(components)(
+                    meta.rest ?? meta,
+                )({
+                    ...attribute,
+                    "x-typia-rest":
+                        i === tuple.elements.length - 1 && meta.rest !== null,
+                    "x-typia-required": meta.required,
+                    "x-typia-optional": meta.optional,
+                }),
+            ),
+            ...attribute,
+            minItems: !!tuple.elements.at(-1)?.rest
+                ? tuple.elements.length - 1
+                : tuple.elements.filter((x) => !x.optional).length,
+            maxItems: !!tuple.elements.at(-1)?.rest
+                ? undefined
+                : tuple.elements.length,
+        };
+        if (options.purpose === "ajv")
+            if (tuple.elements.length === 0) return schema;
+            else if (!tuple.elements.at(-1)?.rest) return schema;
+
+        const wrapper: IJsonSchema.IArray = {
+            ...schema,
+            items: application_schema(options)(false)(components)(
+                tuple.elements.reduce(
+                    (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
+                    Metadata.initialize(),
+                ),
+            )(tuple.recursive ? {} : attribute),
+            "x-typia-tuple": schema,
+            minItems: schema.minItems,
+            maxItems: schema.maxItems,
+        };
+        return wrapper;
+    };

package/src/programmers/internal/check_array.ts

@@ -1,30 +1,30 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_array_length } from "./check_array_length";
-import { check_custom } from "./check_custom";
-
-/**
- * @internal
- */
-export const check_array =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
-    (input: ts.Expression): ICheckEntry => ({
-        expression: ExpressionFactory.isArray(input),
-        tags: [
-            ...check_array_length(metaTags)(
-                IdentifierFactory.access(input)("length"),
-            ),
-            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
-            // check custom array for legacy (3.7.0)
-        ],
-    });
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_array_length } from "./check_array_length";
+import { check_custom } from "./check_custom";
+
+/**
+ * @internal
+ */
+export const check_array =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => ({
+        expression: ExpressionFactory.isArray(input),
+        tags: [
+            ...check_array_length(metaTags)(
+                IdentifierFactory.access(input)("length"),
+            ),
+            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
+            // check custom array for legacy (3.7.0)
+        ],
+    });

package/src/programmers/internal/check_array_length.ts

@@ -1,35 +1,35 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-/**
- * @internal
- */
-export const check_array_length =
-    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
-        metaTags
-            .map((tag) => ({
-                tag,
-                expression:
-                    tag.kind === "items"
-                        ? ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "minItems"
-                        ? ts.factory.createLessThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "maxItems"
-                        ? ts.factory.createGreaterThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : null!,
-            }))
-            .filter((tuple) => tuple.expression !== null)
-            .map(({ tag, expression }) => ({
-                expected: `Array.length (@${tag.kind} ${tag.value})`,
-                expression,
-            }));
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+/**
+ * @internal
+ */
+export const check_array_length =
+    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
+        metaTags
+            .map((tag) => ({
+                tag,
+                expression:
+                    tag.kind === "items"
+                        ? ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(tag.value),
+                              input,
+                          )
+                        : tag.kind === "minItems"
+                        ? ts.factory.createLessThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              input,
+                          )
+                        : tag.kind === "maxItems"
+                        ? ts.factory.createGreaterThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              input,
+                          )
+                        : null!,
+            }))
+            .filter((tuple) => tuple.expression !== null)
+            .map(({ tag, expression }) => ({
+                expected: `Array.length (@${tag.kind} ${tag.value})`,
+                expression,
+            }));

package/src/programmers/internal/check_bigint.ts

@@ -1,110 +1,110 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
-
-/**
- * @internal
- */
-export const check_bigint =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTag: IJsDocTagInfo[]) =>
-    (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataTag, ts.Expression][] = [];
-        for (const tag of metaTags) {
-            if (tag.kind === "type" && tag.value === "uint64")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ExpressionFactory.bigint(0),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "multipleOf")
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ExpressionFactory.bigint(0),
-                        ts.factory.createModulo(
-                            input,
-                            ExpressionFactory.bigint(tag.value),
-                        ),
-                    ),
-                ]);
-            else if (tag.kind === "step") {
-                const modulo = ts.factory.createModulo(
-                    input,
-                    ExpressionFactory.bigint(tag.value),
-                );
-                const minimum =
-                    (metaTags.find(
-                        (tag) =>
-                            tag.kind === "minimum" ||
-                            tag.kind === "exclusiveMinimum",
-                    )?.value as number | undefined) ?? undefined;
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ExpressionFactory.bigint(0),
-                        minimum !== undefined
-                            ? ts.factory.createSubtract(
-                                  modulo,
-                                  ExpressionFactory.bigint(minimum),
-                              )
-                            : modulo,
-                    ),
-                ]);
-            } else if (tag.kind === "minimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "maximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThanEquals(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMinimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThan(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMaximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThan(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-        }
-        return {
-            expression: ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("bigint"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-            tags: [
-                ...entries.map(([tag, expression]) => ({
-                    expected: `bigint (@${tag.kind} ${tag.value})`,
-                    expression,
-                })),
-                ...check_custom("bigint")(importer)(jsDocTag)(input),
-            ],
-        };
-    };
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
+
+/**
+ * @internal
+ */
+export const check_bigint =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTag: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => {
+        const entries: [IMetadataTag, ts.Expression][] = [];
+        for (const tag of metaTags) {
+            if (tag.kind === "type" && tag.value === "uint64")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThanEquals(
+                        ExpressionFactory.bigint(0),
+                        input,
+                    ),
+                ]);
+            else if (tag.kind === "multipleOf")
+                entries.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        ExpressionFactory.bigint(0),
+                        ts.factory.createModulo(
+                            input,
+                            ExpressionFactory.bigint(tag.value),
+                        ),
+                    ),
+                ]);
+            else if (tag.kind === "step") {
+                const modulo = ts.factory.createModulo(
+                    input,
+                    ExpressionFactory.bigint(tag.value),
+                );
+                const minimum =
+                    (metaTags.find(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    )?.value as number | undefined) ?? undefined;
+                entries.push([
+                    tag,
+                    ts.factory.createStrictEquality(
+                        ExpressionFactory.bigint(0),
+                        minimum !== undefined
+                            ? ts.factory.createSubtract(
+                                  modulo,
+                                  ExpressionFactory.bigint(minimum),
+                              )
+                            : modulo,
+                    ),
+                ]);
+            } else if (tag.kind === "minimum")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThanEquals(
+                        ExpressionFactory.bigint(tag.value),
+                        input,
+                    ),
+                ]);
+            else if (tag.kind === "maximum")
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThanEquals(
+                        ExpressionFactory.bigint(tag.value),
+                        input,
+                    ),
+                ]);
+            else if (tag.kind === "exclusiveMinimum")
+                entries.push([
+                    tag,
+                    ts.factory.createLessThan(
+                        ExpressionFactory.bigint(tag.value),
+                        input,
+                    ),
+                ]);
+            else if (tag.kind === "exclusiveMaximum")
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThan(
+                        ExpressionFactory.bigint(tag.value),
+                        input,
+                    ),
+                ]);
+        }
+        return {
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("bigint"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            tags: [
+                ...entries.map(([tag, expression]) => ({
+                    expected: `bigint (@${tag.kind} ${tag.value})`,
+                    expression,
+                })),
+                ...check_custom("bigint")(importer)(jsDocTag)(input),
+            ],
+        };
+    };

package/src/programmers/internal/check_custom.ts

@@ -1,31 +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) => ({
-            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,
+                ],
+            ),
+        }));