typia 5.5.7 → 5.5.8

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(
-            "decode",
-            HttpHeadersProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("decode"),
-              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(
+            "decode",
+            HttpHeadersProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              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,75 +1,75 @@
-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(
-            "decode",
-            HttpQueryProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type, name),
-          ),
-          StatementFactory.constant(
-            "output",
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("decode"),
-              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(
+            "decode",
+            HttpQueryProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type, name),
+          ),
+          StatementFactory.constant(
+            "output",
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              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/JSON_SCHEMA_PREFIX.ts

@@ -1 +1 @@
-export const JSON_COMPONENTS_PREFIX = "#/components";
+export const JSON_COMPONENTS_PREFIX = "#/components";

package/src/programmers/internal/application_alias.ts

@@ -1,74 +1,74 @@
-import { CommentFactory } from "../../factories/CommentFactory";
-
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
-
-import { IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
-import { application_object } from "./application_object";
-import { application_schema } from "./application_schema";
-
-export const application_alias =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: IJsonComponents) =>
-  (alias: MetadataAlias) =>
-  (nullable: boolean): IJsonSchema.IReference => {
-    if (alias.value.size() === 1 && alias.value.objects.length === 1)
-      return application_object(options)(components)(alias.value.objects[0]!)(
-        nullable,
-      ) as IJsonSchema.IReference;
-
-    const key: string =
-      options.purpose === "ajv"
-        ? alias.name
-        : `${alias.name}${nullable ? ".Nullable" : ""}`;
-    const $id: string = `${JSON_COMPONENTS_PREFIX}/schemas/${key}`;
-
-    // TEMPORARY ASSIGNMENT
-    if (components.schemas?.[key] === undefined) {
-      components.schemas ??= {};
-      components.schemas[key] = {
-        $id: key,
-      } as any;
-
-      // GENERATE SCHEM
-      const schema: IJsonSchema = application_schema(options)(blockNever)(
-        components,
-      )(alias.value)({
-        deprecated:
-          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
-        title: (() => {
-          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
-            (tag) => tag.name === "title",
-          );
-          return info?.text?.length
-            ? CommentFactory.merge(info.text)
-            : undefined;
-        })(),
-        description: alias.description ?? undefined,
-        "x-typia-jsDocTags": (() => {
-          const filtered = alias.jsDocTags.filter(
-            (tag) =>
-              tag.name !== "title" &&
-              tag.name !== "deprecated" &&
-              tag.name !== "hidden",
-          );
-          return filtered.length ? filtered : undefined;
-        })(),
-      })!;
-      if (options.surplus === false && schema["x-typia-jsDocTags"]?.length)
-        delete (schema as any)["x-typia-jsDocTags"];
-
-      components.schemas ??= {};
-      components.schemas[key] = {
-        $id: options.purpose === "ajv" ? $id : undefined,
-        $recursiveAnchor:
-          (options.purpose === "ajv" && alias.recursive) || undefined,
-        ...schema,
-      };
-    }
-    return { $ref: $id };
-  };
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
+import { MetadataAlias } from "../../schemas/metadata/MetadataAlias";
+
+import { IJsonSchema } from "../../module";
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { JSON_COMPONENTS_PREFIX } from "./JSON_SCHEMA_PREFIX";
+import { application_object } from "./application_object";
+import { application_schema } from "./application_schema";
+
+export const application_alias =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: IJsonComponents) =>
+  (alias: MetadataAlias) =>
+  (nullable: boolean): IJsonSchema.IReference => {
+    if (alias.value.size() === 1 && alias.value.objects.length === 1)
+      return application_object(options)(components)(alias.value.objects[0]!)(
+        nullable,
+      ) as IJsonSchema.IReference;
+
+    const key: string =
+      options.purpose === "ajv"
+        ? alias.name
+        : `${alias.name}${nullable ? ".Nullable" : ""}`;
+    const $id: string = `${JSON_COMPONENTS_PREFIX}/schemas/${key}`;
+
+    // TEMPORARY ASSIGNMENT
+    if (components.schemas?.[key] === undefined) {
+      components.schemas ??= {};
+      components.schemas[key] = {
+        $id: key,
+      } as any;
+
+      // GENERATE SCHEM
+      const schema: IJsonSchema = application_schema(options)(blockNever)(
+        components,
+      )(alias.value)({
+        deprecated:
+          alias.jsDocTags.some((tag) => tag.name === "deprecated") || undefined,
+        title: (() => {
+          const info: IJsDocTagInfo | undefined = alias.jsDocTags.find(
+            (tag) => tag.name === "title",
+          );
+          return info?.text?.length
+            ? CommentFactory.merge(info.text)
+            : undefined;
+        })(),
+        description: alias.description ?? undefined,
+        "x-typia-jsDocTags": (() => {
+          const filtered = alias.jsDocTags.filter(
+            (tag) =>
+              tag.name !== "title" &&
+              tag.name !== "deprecated" &&
+              tag.name !== "hidden",
+          );
+          return filtered.length ? filtered : undefined;
+        })(),
+      })!;
+      if (options.surplus === false && schema["x-typia-jsDocTags"]?.length)
+        delete (schema as any)["x-typia-jsDocTags"];
+
+      components.schemas ??= {};
+      components.schemas[key] = {
+        $id: options.purpose === "ajv" ? $id : undefined,
+        $recursiveAnchor:
+          (options.purpose === "ajv" && alias.recursive) || undefined,
+        ...schema,
+      };
+    }
+    return { $ref: $id };
+  };

package/src/programmers/internal/application_array.ts

@@ -1,63 +1,63 @@
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-/**
- * @internal
- */
-export const application_array =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (components: IJsonComponents) =>
-  (array: MetadataArray): IJsonSchema.IArray[] => {
-    // BASE SCHEMA
-    const items: IJsonSchema = application_schema(options)(false)(components)(
-      array.type.value,
-    )({});
-    const base: IJsonSchema.IArray = {
-      type: "array",
-      items: null!,
-    };
-    const out = (schema: IJsonSchema.IArray) => {
-      schema.items = items;
-      return schema;
-    };
-    if (array.tags.length === 0) return [out(base)];
-
-    // CONSIDER TYPE TAGS
-    const union: IJsonSchema.IArray[] = array.tags.map(
-      (row) => application_array_tags(options)({ ...base })(row)!,
-    );
-    const map: Map<string, IJsonSchema.IArray> = new Map(
-      union.map((u) => [JSON.stringify(u), u]),
-    );
-    return [...map.values()].map((s) => out(s));
-  };
-
-const application_array_tags =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (schema: IJsonSchema.IArray) =>
-  (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
-    for (const tag of row
-      .slice()
-      .sort((a, b) => a.kind.localeCompare(b.kind))) {
-      if (tag.kind === "minItems" && typeof tag.value === "number")
-        schema.minItems = tag.value;
-      else if (tag.kind === "maxItems" && typeof tag.value === "number")
-        schema.maxItems = tag.value;
-      if (tag.schema) Object.assign(schema, tag.schema);
-    }
-    if (options.surplus)
-      schema["x-typia-typeTags"] = row.map((tag) => ({
-        target: tag.target,
-        name: tag.name,
-        kind: tag.kind,
-        value: tag.value,
-        validate: tag.validate,
-        exclusive: tag.exclusive,
-      }));
-    return schema;
-  };
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+/**
+ * @internal
+ */
+export const application_array =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  (components: IJsonComponents) =>
+  (array: MetadataArray): IJsonSchema.IArray[] => {
+    // BASE SCHEMA
+    const items: IJsonSchema = application_schema(options)(false)(components)(
+      array.type.value,
+    )({});
+    const base: IJsonSchema.IArray = {
+      type: "array",
+      items: null!,
+    };
+    const out = (schema: IJsonSchema.IArray) => {
+      schema.items = items;
+      return schema;
+    };
+    if (array.tags.length === 0) return [out(base)];
+
+    // CONSIDER TYPE TAGS
+    const union: IJsonSchema.IArray[] = array.tags.map(
+      (row) => application_array_tags(options)({ ...base })(row)!,
+    );
+    const map: Map<string, IJsonSchema.IArray> = new Map(
+      union.map((u) => [JSON.stringify(u), u]),
+    );
+    return [...map.values()].map((s) => out(s));
+  };
+
+const application_array_tags =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  (schema: IJsonSchema.IArray) =>
+  (row: IMetadataTypeTag[]): IJsonSchema.IArray => {
+    for (const tag of row
+      .slice()
+      .sort((a, b) => a.kind.localeCompare(b.kind))) {
+      if (tag.kind === "minItems" && typeof tag.value === "number")
+        schema.minItems = tag.value;
+      else if (tag.kind === "maxItems" && typeof tag.value === "number")
+        schema.maxItems = tag.value;
+      if (tag.schema) Object.assign(schema, tag.schema);
+    }
+    if (options.surplus)
+      schema["x-typia-typeTags"] = row.map((tag) => ({
+        target: tag.target,
+        name: tag.name,
+        kind: tag.kind,
+        value: tag.value,
+        validate: tag.validate,
+        exclusive: tag.exclusive,
+      }));
+    return schema;
+  };