typia 5.1.3 → 5.1.4-dev.20230929

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpValidateHeadersProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpHeadersProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Resolved<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "headers",
-                        HttpHeadersProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("headers"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                            ts.factory.createTypeReferenceNode("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpValidateHeadersProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpHeadersProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.IValidation<typia.Resolved<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "headers",
+                        HttpHeadersProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("headers"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            ts.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-
-export namespace HttpValidateQueryProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpQueryProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Resolved<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "query",
-                        HttpQueryProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("query"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                            ts.factory.createTypeReferenceNode("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+
+export namespace HttpValidateQueryProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpQueryProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.IValidation<typia.Resolved<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "query",
+                        HttpQueryProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("query"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            ts.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/internal/application_boolean.ts

@@ -1,30 +1,30 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_boolean =
-    (atomic: MetadataAtomic) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema.IBoolean[] => {
-        const base: IJsonSchema.IBoolean = {
-            ...attribute,
-            default: application_default(attribute)(
-                (alias) => alias === "true" || alias === "false",
-            )((str) => Boolean(str)),
-            type: "boolean",
-        };
-        const defaultTags: IMetadataTypeTag[] = atomic.tags
-            .filter((row) => row.some((tag) => tag.kind === "default"))
-            .map((row) => row.filter((tag) => tag.kind === "default"))
-            .flat();
-        if (defaultTags.length === 0) return [base];
-        return defaultTags.map((tag) => ({
-            ...base,
-            default: tag.value,
-            "x-typia-typeTags": defaultTags,
-        }));
-    };
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_boolean =
+    (atomic: MetadataAtomic) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema.IBoolean[] => {
+        const base: IJsonSchema.IBoolean = {
+            ...attribute,
+            default: application_default(attribute)(
+                (alias) => alias === "true" || alias === "false",
+            )((str) => Boolean(str)),
+            type: "boolean",
+        };
+        const defaultTags: IMetadataTypeTag[] = atomic.tags
+            .filter((row) => row.some((tag) => tag.kind === "default"))
+            .map((row) => row.filter((tag) => tag.kind === "default"))
+            .flat();
+        if (defaultTags.length === 0) return [base];
+        return defaultTags.map((tag) => ({
+            ...base,
+            default: tag.value,
+            "x-typia-typeTags": defaultTags,
+        }));
+    };

package/src/programmers/internal/application_number.ts

@@ -1,90 +1,90 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-type Schema = IJsonSchema.INumber | IJsonSchema.IInteger;
-
-/**
- * @internal
- */
-export const application_number =
-    (atomic: MetadataAtomic) =>
-    (attribute: IJsonSchema.IAttribute): Array<Schema> => {
-        // BASE CONFIGURATION
-        const base: Schema = {
-            ...attribute,
-            type: "number",
-        };
-        const out = (schema: Schema) => {
-            schema.default ??= application_default(attribute)((str) => {
-                const value: number = Number(str);
-                const conditions: boolean[] = [!Number.isNaN(value)];
-                if (schema.minimum !== undefined)
-                    if (schema.exclusiveMinimum === true)
-                        conditions.push(value > schema.minimum);
-                    else conditions.push(value >= schema.minimum);
-                if (schema.maximum !== undefined)
-                    if (schema.exclusiveMaximum === true)
-                        conditions.push(value < schema.maximum);
-                    else conditions.push(value <= schema.maximum);
-                if (schema.multipleOf !== undefined)
-                    conditions.push(value % schema.multipleOf === 0);
-                return conditions.every((cond) => cond);
-            })((str) => Number(str));
-            return schema;
-        };
-        if (atomic.tags.length === 0) return [out(base)];
-
-        // CONSIDER TYPE TAGS
-        const union: Schema[] = atomic.tags.map(
-            (row) => application_number_tags({ ...base })(row)!,
-        );
-        const map: Map<string, Schema> = new Map(
-            union.map((u) => [JSON.stringify(u), u]),
-        );
-        return [...map.values()].map((s) => out(s));
-    };
-
-const application_number_tags =
-    (base: Schema) =>
-    (row: IMetadataTypeTag[]): Schema => {
-        for (const tag of row
-            .slice()
-            .sort((a, b) => a.kind.localeCompare(b.kind))) {
-            if (
-                tag.kind === "type" &&
-                (tag.value === "int32" ||
-                    tag.value === "uint32" ||
-                    tag.value === "int64" ||
-                    tag.value === "uint64")
-            )
-                base.type = "integer";
-            else if (tag.kind === "minimum" && typeof tag.value === "number")
-                base.minimum = tag.value;
-            else if (tag.kind === "maximum" && typeof tag.value === "number")
-                base.maximum = tag.value;
-            else if (
-                tag.kind === "exclusiveMinimum" &&
-                typeof tag.value === "number"
-            ) {
-                base.minimum = tag.value;
-                base.exclusiveMinimum = true;
-            } else if (
-                tag.kind === "exclusiveMaximum" &&
-                typeof tag.value === "number"
-            ) {
-                base.maximum = tag.value;
-                base.exclusiveMaximum = true;
-            } else if (
-                tag.kind === "multipleOf" &&
-                typeof tag.value === "number"
-            )
-                base.multipleOf = tag.value;
-            else if (tag.kind === "default" && typeof tag.value === "number")
-                base.default = tag.value;
-        }
-        base["x-typia-typeTags"] = row;
-        return base;
-    };
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+type Schema = IJsonSchema.INumber | IJsonSchema.IInteger;
+
+/**
+ * @internal
+ */
+export const application_number =
+    (atomic: MetadataAtomic) =>
+    (attribute: IJsonSchema.IAttribute): Array<Schema> => {
+        // BASE CONFIGURATION
+        const base: Schema = {
+            ...attribute,
+            type: "number",
+        };
+        const out = (schema: Schema) => {
+            schema.default ??= application_default(attribute)((str) => {
+                const value: number = Number(str);
+                const conditions: boolean[] = [!Number.isNaN(value)];
+                if (schema.minimum !== undefined)
+                    if (schema.exclusiveMinimum === true)
+                        conditions.push(value > schema.minimum);
+                    else conditions.push(value >= schema.minimum);
+                if (schema.maximum !== undefined)
+                    if (schema.exclusiveMaximum === true)
+                        conditions.push(value < schema.maximum);
+                    else conditions.push(value <= schema.maximum);
+                if (schema.multipleOf !== undefined)
+                    conditions.push(value % schema.multipleOf === 0);
+                return conditions.every((cond) => cond);
+            })((str) => Number(str));
+            return schema;
+        };
+        if (atomic.tags.length === 0) return [out(base)];
+
+        // CONSIDER TYPE TAGS
+        const union: Schema[] = atomic.tags.map(
+            (row) => application_number_tags({ ...base })(row)!,
+        );
+        const map: Map<string, Schema> = new Map(
+            union.map((u) => [JSON.stringify(u), u]),
+        );
+        return [...map.values()].map((s) => out(s));
+    };
+
+const application_number_tags =
+    (base: Schema) =>
+    (row: IMetadataTypeTag[]): Schema => {
+        for (const tag of row
+            .slice()
+            .sort((a, b) => a.kind.localeCompare(b.kind))) {
+            if (
+                tag.kind === "type" &&
+                (tag.value === "int32" ||
+                    tag.value === "uint32" ||
+                    tag.value === "int64" ||
+                    tag.value === "uint64")
+            )
+                base.type = "integer";
+            else if (tag.kind === "minimum" && typeof tag.value === "number")
+                base.minimum = tag.value;
+            else if (tag.kind === "maximum" && typeof tag.value === "number")
+                base.maximum = tag.value;
+            else if (
+                tag.kind === "exclusiveMinimum" &&
+                typeof tag.value === "number"
+            ) {
+                base.minimum = tag.value;
+                base.exclusiveMinimum = true;
+            } else if (
+                tag.kind === "exclusiveMaximum" &&
+                typeof tag.value === "number"
+            ) {
+                base.maximum = tag.value;
+                base.exclusiveMaximum = true;
+            } else if (
+                tag.kind === "multipleOf" &&
+                typeof tag.value === "number"
+            )
+                base.multipleOf = tag.value;
+            else if (tag.kind === "default" && typeof tag.value === "number")
+                base.default = tag.value;
+        }
+        base["x-typia-typeTags"] = row;
+        return base;
+    };