typia 7.0.0-dev.20240916 → 7.0.0-dev.20240919

package/src/programmers/internal/application_v31_tuple.ts

@@ -6,16 +6,17 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 /**
  * @internal
  */
-export const application_v31_tuple =
-  (generator: (meta: Metadata) => OpenApi.IJsonSchema) =>
-  (tuple: MetadataTuple): OpenApi.IJsonSchema.ITuple => {
-    const tail: Metadata | null = tuple.type.elements.at(-1)?.rest ?? null;
-    const prefixItems: Metadata[] = tuple.type.isRest()
-      ? tuple.type.elements.slice(0, -1)
-      : tuple.type.elements;
-    return {
-      type: "array",
-      prefixItems: prefixItems.map(generator),
-      additionalItems: tail ? generator(tail) : false,
-    };
+export const application_v31_tuple = (props: {
+  generator: (meta: Metadata) => OpenApi.IJsonSchema;
+  tuple: MetadataTuple;
+}): OpenApi.IJsonSchema.ITuple => {
+  const tail: Metadata | null = props.tuple.type.elements.at(-1)?.rest ?? null;
+  const prefixItems: Metadata[] = props.tuple.type.isRest()
+    ? props.tuple.type.elements.slice(0, -1)
+    : props.tuple.type.elements;
+  return {
+    type: "array",
+    prefixItems: prefixItems.map(props.generator),
+    additionalItems: tail ? props.generator(tail) : false,
   };
+};

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 { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_array_length =
-  (project: ITypiaContext) =>
-  (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: ITypiaContext) =>
-  (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.transformer)(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 { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_array_length =
+  (project: ITypiaContext) =>
+  (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: ITypiaContext) =>
+  (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.transformer)(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 { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_bigint =
-  (project: ITypiaContext) =>
-  (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: ITypiaContext) =>
-  (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.transformer)(tag.validate!)
-          )(input),
-        })),
-      );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_bigint =
+  (project: ITypiaContext) =>
+  (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: ITypiaContext) =>
+  (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.transformer)(tag.validate!)
+          )(input),
+        })),
+      );

package/src/programmers/internal/check_dynamic_key.ts

@@ -1,174 +1,174 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_bigint } from "./check_bigint";
-import { check_number } from "./check_number";
-import { check_string } from "./check_string";
-import { check_template } from "./check_template";
-
-export const check_dynamic_key =
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter) =>
-  (input: ts.Expression, metadata: Metadata): ts.Expression => {
-    // IF PURE STRING EXISTS, THEN SKIP VALIDATION
-    if (
-      (metadata.atomics.length !== 0 &&
-        metadata.atomics.some(
-          (a) =>
-            a.type === "string" &&
-            a.tags.filter((row) => row.every((t) => t.validate !== undefined))
-              .length === 0,
-        )) ||
-      (metadata.natives.length !== 0 &&
-        metadata.natives.some((type) => type === "String"))
-    )
-      return ts.factory.createTrue();
-
-    const conditions: ts.Expression[] = [];
-
-    // NULLISH COALESCING
-    if (metadata.nullable === true)
-      conditions.push(
-        ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral("null"),
-          input,
-        ),
-      );
-    if (metadata.isRequired() === false)
-      conditions.push(
-        ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral("undefined"),
-          input,
-        ),
-      );
-
-    // ATOMICS
-    for (const atom of metadata.atomics)
-      if (atom.type === "boolean")
-        conditions.push(
-          ts.factory.createLogicalOr(
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("false"),
-              input,
-            ),
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("true"),
-              input,
-            ),
-          ),
-        );
-      else if (atom.type === "bigint")
-        conditions.push(
-          ts.factory.createLogicalAnd(
-            ts.factory.createCallExpression(
-              importer.use("is_bigint_string"),
-              undefined,
-              [input],
-            ),
-            atomist(
-              check_bigint(project)(atom)(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("BigInt"),
-                  undefined,
-                  [input],
-                ),
-              ),
-            ),
-          ),
-        );
-      else if (atom.type === "number")
-        conditions.push(
-          atomist(
-            check_number(project, true)(atom)(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Number"),
-                undefined,
-                [input],
-              ),
-            ),
-          ),
-        );
-      else conditions.push(atomist(check_string(project)(atom)(input)));
-
-    // CONSTANTS
-    for (const constant of metadata.constants)
-      for (const { value } of constant.values)
-        conditions.push(
-          ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral(String(value)),
-            input,
-          ),
-        );
-
-    // TEMPLATES
-    if (!!metadata.templates.length)
-      conditions.push(atomist(check_template(metadata.templates)(input)));
-
-    // NATIVES
-    for (const native of metadata.natives)
-      if (native === "Boolean")
-        conditions.push(
-          ts.factory.createLogicalOr(
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("false"),
-              input,
-            ),
-            ts.factory.createStrictEquality(
-              ts.factory.createStringLiteral("true"),
-              input,
-            ),
-          ),
-        );
-      else if (native === "BigInt")
-        conditions.push(
-          ts.factory.createCallExpression(
-            importer.use("is_bigint_string"),
-            undefined,
-            [input],
-          ),
-        );
-      else if (native === "Number")
-        conditions.push(
-          ts.factory.createStrictEquality(
-            ts.factory.createFalse(),
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Number.isNaN"),
-              undefined,
-              [
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("Number"),
-                  undefined,
-                  [input],
-                ),
-              ],
-            ),
-          ),
-        );
-
-    return conditions.length === 0
-      ? ts.factory.createTrue()
-      : conditions.length === 1
-        ? conditions[0]!
-        : conditions.reduce(ts.factory.createLogicalOr);
-  };
-
-const atomist = (entry: ICheckEntry) =>
-  [
-    ...(entry.expression ? [entry.expression] : []),
-    ...(entry.conditions.length === 0
-      ? []
-      : [
-          entry.conditions
-            .map((set) =>
-              set
-                .map((s) => s.expression)
-                .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-            )
-            .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-        ]),
-  ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_bigint } from "./check_bigint";
+import { check_number } from "./check_number";
+import { check_string } from "./check_string";
+import { check_template } from "./check_template";
+
+export const check_dynamic_key =
+  (project: ITypiaContext) =>
+  (importer: FunctionImporter) =>
+  (input: ts.Expression, metadata: Metadata): ts.Expression => {
+    // IF PURE STRING EXISTS, THEN SKIP VALIDATION
+    if (
+      (metadata.atomics.length !== 0 &&
+        metadata.atomics.some(
+          (a) =>
+            a.type === "string" &&
+            a.tags.filter((row) => row.every((t) => t.validate !== undefined))
+              .length === 0,
+        )) ||
+      (metadata.natives.length !== 0 &&
+        metadata.natives.some((type) => type === "String"))
+    )
+      return ts.factory.createTrue();
+
+    const conditions: ts.Expression[] = [];
+
+    // NULLISH COALESCING
+    if (metadata.nullable === true)
+      conditions.push(
+        ts.factory.createStrictEquality(
+          ts.factory.createStringLiteral("null"),
+          input,
+        ),
+      );
+    if (metadata.isRequired() === false)
+      conditions.push(
+        ts.factory.createStrictEquality(
+          ts.factory.createStringLiteral("undefined"),
+          input,
+        ),
+      );
+
+    // ATOMICS
+    for (const atom of metadata.atomics)
+      if (atom.type === "boolean")
+        conditions.push(
+          ts.factory.createLogicalOr(
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("false"),
+              input,
+            ),
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("true"),
+              input,
+            ),
+          ),
+        );
+      else if (atom.type === "bigint")
+        conditions.push(
+          ts.factory.createLogicalAnd(
+            ts.factory.createCallExpression(
+              importer.use("is_bigint_string"),
+              undefined,
+              [input],
+            ),
+            atomist(
+              check_bigint(project)(atom)(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("BigInt"),
+                  undefined,
+                  [input],
+                ),
+              ),
+            ),
+          ),
+        );
+      else if (atom.type === "number")
+        conditions.push(
+          atomist(
+            check_number(project, true)(atom)(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Number"),
+                undefined,
+                [input],
+              ),
+            ),
+          ),
+        );
+      else conditions.push(atomist(check_string(project)(atom)(input)));
+
+    // CONSTANTS
+    for (const constant of metadata.constants)
+      for (const { value } of constant.values)
+        conditions.push(
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral(String(value)),
+            input,
+          ),
+        );
+
+    // TEMPLATES
+    if (!!metadata.templates.length)
+      conditions.push(atomist(check_template(metadata.templates)(input)));
+
+    // NATIVES
+    for (const native of metadata.natives)
+      if (native === "Boolean")
+        conditions.push(
+          ts.factory.createLogicalOr(
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("false"),
+              input,
+            ),
+            ts.factory.createStrictEquality(
+              ts.factory.createStringLiteral("true"),
+              input,
+            ),
+          ),
+        );
+      else if (native === "BigInt")
+        conditions.push(
+          ts.factory.createCallExpression(
+            importer.use("is_bigint_string"),
+            undefined,
+            [input],
+          ),
+        );
+      else if (native === "Number")
+        conditions.push(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("Number.isNaN"),
+              undefined,
+              [
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("Number"),
+                  undefined,
+                  [input],
+                ),
+              ],
+            ),
+          ),
+        );
+
+    return conditions.length === 0
+      ? ts.factory.createTrue()
+      : conditions.length === 1
+        ? conditions[0]!
+        : conditions.reduce(ts.factory.createLogicalOr);
+  };
+
+const atomist = (entry: ICheckEntry) =>
+  [
+    ...(entry.expression ? [entry.expression] : []),
+    ...(entry.conditions.length === 0
+      ? []
+      : [
+          entry.conditions
+            .map((set) =>
+              set
+                .map((s) => s.expression)
+                .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+            )
+            .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+        ]),
+  ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));