typia 5.5.8 → 5.5.9-dev.20240402

package/src/programmers/internal/application_schema.ts

@@ -1,165 +1,165 @@
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_alias } from "./application_alias";
-import { application_array } from "./application_array";
-import { application_boolean } from "./application_boolean";
-import { application_constant } from "./application_constant";
-import { application_escaped } from "./application_escaped";
-import { application_native } from "./application_native";
-import { application_number } from "./application_number";
-import { application_object } from "./application_object";
-import { application_string } from "./application_string";
-import { application_templates } from "./application_templates";
-import { application_tuple } from "./application_tuple";
-
-/**
- * @internal
- */
-export const application_schema =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  <BlockNever extends boolean>(blockNever: BlockNever) =>
-  (components: IJsonComponents) =>
-  (meta: Metadata) =>
-  (
-    attribute: IJsonSchema.IAttribute,
-  ): BlockNever extends true ? IJsonSchema | null : IJsonSchema => {
-    // VULNERABLE CASE
-    if (meta.any === true)
-      return {
-        ...attribute,
-        type: undefined,
-      };
-    else if (meta.nullable && meta.empty())
-      return { type: "null", ...attribute };
-
-    //----
-    // GATHER UNION SCHEMAS
-    //----
-    const union: IJsonSchema[] = [];
-    if (meta.nullable && options.purpose !== "swagger")
-      union.push({
-        ...attribute,
-        type: "null",
-      });
-
-    const insert =
-      meta.nullable && options.purpose === "swagger"
-        ? (schema: IJsonSchema) =>
-            union.push({
-              ...schema,
-              nullable: (schema as IJsonSchema.ISignificant<any>).type
-                ? true
-                : undefined,
-            } as IJsonSchema)
-        : (schema: IJsonSchema) => union.push(schema);
-
-    // toJSON() METHOD
-    if (meta.escaped !== null)
-      application_escaped(options)(blockNever)(components)(
-        meta.escaped,
-      ).forEach(insert);
-
-    // ATOMIC TYPES
-    if (meta.templates.length && AtomicPredicator.template(meta))
-      insert(application_templates(meta)(attribute));
-    for (const constant of meta.constants)
-      if (constant.type === "bigint") throw new TypeError(NO_BIGINT);
-      else if (
-        (constant.type === "string" && meta.templates.length) ||
-        AtomicPredicator.constant(meta)(constant.type) === false
-      )
-        continue;
-      else insert(application_constant(constant)(attribute));
-    for (const a of meta.atomics)
-      if (a.type === "bigint") throw new TypeError(NO_BIGINT);
-      else if (a.type === "boolean")
-        application_boolean(options)(a)(attribute).forEach(insert);
-      else if (a.type === "number")
-        application_number(options)(a)(attribute).forEach(insert);
-      else if (a.type === "string")
-        application_string(options)(meta)(a)(attribute).forEach(insert);
-
-    // ARRAY
-    for (const array of meta.arrays)
-      application_array(options)(components)(array).forEach(insert);
-
-    // TUPLE
-    for (const tuple of meta.tuples)
-      insert(application_tuple(options)(components)(tuple)(attribute));
-
-    // NATIVES
-    for (const native of meta.natives)
-      if (AtomicPredicator.native(native)) {
-        const type: string = native.toLowerCase();
-        if (meta.atomics.some((a) => a.type === type)) continue;
-        else if (type === "bigint") throw new TypeError(NO_BIGINT);
-        else if (type === "boolean")
-          insert(
-            application_boolean(options)(
-              MetadataAtomic.create({
-                type: "boolean",
-                tags: [],
-              }),
-            )(attribute)[0]!,
-          );
-        else if (type === "number")
-          insert(
-            application_number(options)(
-              MetadataAtomic.create({
-                type: "number",
-                tags: [],
-              }),
-            )(attribute)[0]!,
-          );
-        else if (type === "string")
-          insert(
-            application_string(options)(meta)(
-              MetadataAtomic.create({
-                type: "string",
-                tags: [],
-              }),
-            )(attribute)[0]!,
-          );
-      } else
-        insert(application_native(options)(components)(native)(meta.nullable));
-    if (meta.sets.length)
-      insert(application_native(options)(components)(`Set`)(meta.nullable));
-    if (meta.maps.length)
-      insert(application_native(options)(components)(`Map`)(meta.nullable));
-
-    // OBJECT
-    for (const obj of meta.objects)
-      insert(application_object(options)(components)(obj)(meta.nullable));
-
-    // ALIASES
-    for (const alias of meta.aliases)
-      insert(
-        application_alias(options)(blockNever)(components)(alias)(
-          meta.nullable,
-        ),
-      );
-
-    //----
-    // RETURNS
-    //----
-    if (union.length === 0)
-      return blockNever === true
-        ? null!
-        : {
-            ...attribute,
-            type: undefined,
-          };
-    else if (union.length === 1)
-      return {
-        ...union[0]!,
-        ...attribute,
-      };
-    return { oneOf: union, ...attribute };
-  };
-
-const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { application_alias } from "./application_alias";
+import { application_array } from "./application_array";
+import { application_boolean } from "./application_boolean";
+import { application_constant } from "./application_constant";
+import { application_escaped } from "./application_escaped";
+import { application_native } from "./application_native";
+import { application_number } from "./application_number";
+import { application_object } from "./application_object";
+import { application_string } from "./application_string";
+import { application_templates } from "./application_templates";
+import { application_tuple } from "./application_tuple";
+
+/**
+ * @internal
+ */
+export const application_schema =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  <BlockNever extends boolean>(blockNever: BlockNever) =>
+  (components: IJsonComponents) =>
+  (meta: Metadata) =>
+  (
+    attribute: IJsonSchema.IAttribute,
+  ): BlockNever extends true ? IJsonSchema | null : IJsonSchema => {
+    // VULNERABLE CASE
+    if (meta.any === true)
+      return {
+        ...attribute,
+        type: undefined,
+      };
+    else if (meta.nullable && meta.empty())
+      return { type: "null", ...attribute };
+
+    //----
+    // GATHER UNION SCHEMAS
+    //----
+    const union: IJsonSchema[] = [];
+    if (meta.nullable && options.purpose !== "swagger")
+      union.push({
+        ...attribute,
+        type: "null",
+      });
+
+    const insert =
+      meta.nullable && options.purpose === "swagger"
+        ? (schema: IJsonSchema) =>
+            union.push({
+              ...schema,
+              nullable: (schema as IJsonSchema.ISignificant<any>).type
+                ? true
+                : undefined,
+            } as IJsonSchema)
+        : (schema: IJsonSchema) => union.push(schema);
+
+    // toJSON() METHOD
+    if (meta.escaped !== null)
+      application_escaped(options)(blockNever)(components)(
+        meta.escaped,
+      ).forEach(insert);
+
+    // ATOMIC TYPES
+    if (meta.templates.length && AtomicPredicator.template(meta))
+      insert(application_templates(meta)(attribute));
+    for (const constant of meta.constants)
+      if (constant.type === "bigint") throw new TypeError(NO_BIGINT);
+      else if (
+        (constant.type === "string" && meta.templates.length) ||
+        AtomicPredicator.constant(meta)(constant.type) === false
+      )
+        continue;
+      else insert(application_constant(constant)(attribute));
+    for (const a of meta.atomics)
+      if (a.type === "bigint") throw new TypeError(NO_BIGINT);
+      else if (a.type === "boolean")
+        application_boolean(options)(a)(attribute).forEach(insert);
+      else if (a.type === "number")
+        application_number(options)(a)(attribute).forEach(insert);
+      else if (a.type === "string")
+        application_string(options)(meta)(a)(attribute).forEach(insert);
+
+    // ARRAY
+    for (const array of meta.arrays)
+      application_array(options)(components)(array).forEach(insert);
+
+    // TUPLE
+    for (const tuple of meta.tuples)
+      insert(application_tuple(options)(components)(tuple)(attribute));
+
+    // NATIVES
+    for (const native of meta.natives)
+      if (AtomicPredicator.native(native)) {
+        const type: string = native.toLowerCase();
+        if (meta.atomics.some((a) => a.type === type)) continue;
+        else if (type === "bigint") throw new TypeError(NO_BIGINT);
+        else if (type === "boolean")
+          insert(
+            application_boolean(options)(
+              MetadataAtomic.create({
+                type: "boolean",
+                tags: [],
+              }),
+            )(attribute)[0]!,
+          );
+        else if (type === "number")
+          insert(
+            application_number(options)(
+              MetadataAtomic.create({
+                type: "number",
+                tags: [],
+              }),
+            )(attribute)[0]!,
+          );
+        else if (type === "string")
+          insert(
+            application_string(options)(meta)(
+              MetadataAtomic.create({
+                type: "string",
+                tags: [],
+              }),
+            )(attribute)[0]!,
+          );
+      } else
+        insert(application_native(options)(components)(native)(meta.nullable));
+    if (meta.sets.length)
+      insert(application_native(options)(components)(`Set`)(meta.nullable));
+    if (meta.maps.length)
+      insert(application_native(options)(components)(`Map`)(meta.nullable));
+
+    // OBJECT
+    for (const obj of meta.objects)
+      insert(application_object(options)(components)(obj)(meta.nullable));
+
+    // ALIASES
+    for (const alias of meta.aliases)
+      insert(
+        application_alias(options)(blockNever)(components)(alias)(
+          meta.nullable,
+        ),
+      );
+
+    //----
+    // RETURNS
+    //----
+    if (union.length === 0)
+      return blockNever === true
+        ? null!
+        : {
+            ...attribute,
+            type: undefined,
+          };
+    else if (union.length === 1)
+      return {
+        ...union[0]!,
+        ...attribute,
+      };
+    return { oneOf: union, ...attribute };
+  };
+
+const NO_BIGINT = "Error on typia.application(): does not allow bigint type.";

package/src/programmers/internal/application_string.ts

@@ -1,65 +1,65 @@
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_default_string } from "./application_default_string";
-
-/**
- * @internal
- */
-export const application_string =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (meta: Metadata) =>
-  (atomic: MetadataAtomic) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IString[] => {
-    // DEFAULT CONFIGURATION
-    const base: IJsonSchema.IString = {
-      type: "string",
-    };
-    const out = (schema: IJsonSchema.IString) => {
-      schema.default ??= application_default_string(meta)(attribute)(base);
-      return schema;
-    };
-    if (atomic.tags.length === 0) return [out(base)];
-
-    // CONSIDER TYPE TAGS
-    const union: IJsonSchema.IString[] = atomic.tags.map(
-      (row) => application_string_tags(options)({ ...base })(row)!,
-    );
-    const map: Map<string, IJsonSchema.IString> = new Map(
-      union.map((u) => [JSON.stringify(u), u]),
-    );
-    return [...map.values()].map((s) => out(s));
-  };
-
-const application_string_tags =
-  (options: JsonApplicationProgrammer.IOptions) =>
-  (base: IJsonSchema.IString) =>
-  (row: IMetadataTypeTag[]): IJsonSchema.IString | null => {
-    for (const tag of row
-      .slice()
-      .sort((a, b) => a.kind.localeCompare(b.kind))) {
-      if (tag.kind === "minLength" && typeof tag.value === "number")
-        base.minLength = tag.value;
-      else if (tag.kind === "maxLength" && typeof tag.value === "number")
-        base.maxLength = tag.value;
-      else if (tag.kind === "format" && typeof tag.value === "string")
-        base.format = tag.value;
-      else if (tag.kind === "pattern") base.pattern = tag.value;
-      else if (tag.kind === "default" && typeof tag.value === "string")
-        base.default = tag.value;
-      if (tag.schema) Object.assign(base, tag.schema);
-    }
-    if (options.surplus)
-      base["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 base;
-  };
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { application_default_string } from "./application_default_string";
+
+/**
+ * @internal
+ */
+export const application_string =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  (meta: Metadata) =>
+  (atomic: MetadataAtomic) =>
+  (attribute: IJsonSchema.IAttribute): IJsonSchema.IString[] => {
+    // DEFAULT CONFIGURATION
+    const base: IJsonSchema.IString = {
+      type: "string",
+    };
+    const out = (schema: IJsonSchema.IString) => {
+      schema.default ??= application_default_string(meta)(attribute)(base);
+      return schema;
+    };
+    if (atomic.tags.length === 0) return [out(base)];
+
+    // CONSIDER TYPE TAGS
+    const union: IJsonSchema.IString[] = atomic.tags.map(
+      (row) => application_string_tags(options)({ ...base })(row)!,
+    );
+    const map: Map<string, IJsonSchema.IString> = new Map(
+      union.map((u) => [JSON.stringify(u), u]),
+    );
+    return [...map.values()].map((s) => out(s));
+  };
+
+const application_string_tags =
+  (options: JsonApplicationProgrammer.IOptions) =>
+  (base: IJsonSchema.IString) =>
+  (row: IMetadataTypeTag[]): IJsonSchema.IString | null => {
+    for (const tag of row
+      .slice()
+      .sort((a, b) => a.kind.localeCompare(b.kind))) {
+      if (tag.kind === "minLength" && typeof tag.value === "number")
+        base.minLength = tag.value;
+      else if (tag.kind === "maxLength" && typeof tag.value === "number")
+        base.maxLength = tag.value;
+      else if (tag.kind === "format" && typeof tag.value === "string")
+        base.format = tag.value;
+      else if (tag.kind === "pattern") base.pattern = tag.value;
+      else if (tag.kind === "default" && typeof tag.value === "string")
+        base.default = tag.value;
+      if (tag.schema) Object.assign(base, tag.schema);
+    }
+    if (options.surplus)
+      base["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 base;
+  };

package/src/programmers/internal/application_templates.ts

@@ -1,24 +1,24 @@
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { application_default_string } from "./application_default_string";
-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",
-    };
-    output.pattern = metadata_to_pattern(true)(meta);
-
-    // DEFAULT VALUE
-    output.default = application_default_string(meta)(attribute)(output);
-
-    // RETURNS
-    return output;
-  };
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { application_default_string } from "./application_default_string";
+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",
+    };
+    output.pattern = metadata_to_pattern(true)(meta);
+
+    // DEFAULT VALUE
+    output.default = application_default_string(meta)(attribute)(output);
+
+    // RETURNS
+    return output;
+  };

package/src/programmers/internal/application_tuple.ts

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