typia 5.3.4 → 5.3.5-dev.20231211

package/src/programmers/internal/application_string.ts

@@ -1,58 +1,58 @@
-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 { application_default_string } from "./application_default_string";
-
-/**
- * @internal
- */
-export const application_string =
-  (meta: Metadata) =>
-  (atomic: MetadataAtomic) =>
-  (attribute: IJsonSchema.IAttribute): IJsonSchema.IString[] => {
-    // DEFAULT CONFIGURATION
-    const base: IJsonSchema.IString = {
-      ...attribute,
-      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({ ...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 =
-  (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;
-    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 { application_default_string } from "./application_default_string";
+
+/**
+ * @internal
+ */
+export const application_string =
+  (meta: Metadata) =>
+  (atomic: MetadataAtomic) =>
+  (attribute: IJsonSchema.IAttribute): IJsonSchema.IString[] => {
+    // DEFAULT CONFIGURATION
+    const base: IJsonSchema.IString = {
+      ...attribute,
+      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({ ...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 =
+  (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;
+    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,25 +1,25 @@
-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",
-      ...attribute,
-    };
-    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",
+      ...attribute,
+    };
+    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,55 +1,55 @@
-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)({
-          ...attribute,
-          "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)({
+          ...attribute,
+          "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;
+  };

package/src/programmers/internal/check_array_length.ts

@@ -1,45 +1,45 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_array_length =
-  (project: IProject) =>
-  (array: MetadataArray) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
-      project,
-    )(array.tags)(input);
-
-    return {
-      expected: array.getName(),
-      expression: null,
-      conditions,
-    };
-  };
-
-const check_string_type_tags =
-  (project: IProject) =>
-  (matrix: IMetadataTypeTag[][]) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    matrix
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `Array<> & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.context)(tag.validate!)
-          )(input),
-        })),
-      );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_array_length =
+  (project: IProject) =>
+  (array: MetadataArray) =>
+  (input: ts.Expression): ICheckEntry => {
+    const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
+      project,
+    )(array.tags)(input);
+
+    return {
+      expected: array.getName(),
+      expression: null,
+      conditions,
+    };
+  };
+
+const check_string_type_tags =
+  (project: IProject) =>
+  (matrix: IMetadataTypeTag[][]) =>
+  (input: ts.Expression): ICheckEntry.ICondition[][] =>
+    matrix
+      .map((row) => row.filter((tag) => !!tag.validate))
+      .filter((row) => !!row.length)
+      .map((row) =>
+        row.map((tag) => ({
+          expected: `Array<> & ${tag.name}`,
+          expression: (
+            tag.predicate ??
+            ExpressionFactory.transpile(project.context)(tag.validate!)
+          )(input),
+        })),
+      );

package/src/programmers/internal/check_bigint.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_bigint =
-  (project: IProject) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] =
-      check_bigint_type_tags(project)(atomic)(input);
-
-    return {
-      expected: atomic.getName(),
-      expression: ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("bigint"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-      conditions,
-    };
-  };
-
-/**
- * @internal
- */
-const check_bigint_type_tags =
-  (project: IProject) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    atomic.tags
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `bigint & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.context)(tag.validate!)
-          )(input),
-        })),
-      );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_bigint =
+  (project: IProject) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry => {
+    const conditions: ICheckEntry.ICondition[][] =
+      check_bigint_type_tags(project)(atomic)(input);
+
+    return {
+      expected: atomic.getName(),
+      expression: ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("bigint"),
+        ts.factory.createTypeOfExpression(input),
+      ),
+      conditions,
+    };
+  };
+
+/**
+ * @internal
+ */
+const check_bigint_type_tags =
+  (project: IProject) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry.ICondition[][] =>
+    atomic.tags
+      .map((row) => row.filter((tag) => !!tag.validate))
+      .filter((row) => !!row.length)
+      .map((row) =>
+        row.map((tag) => ({
+          expected: `bigint & ${tag.name}`,
+          expression: (
+            tag.predicate ??
+            ExpressionFactory.transpile(project.context)(tag.validate!)
+          )(input),
+        })),
+      );