typia 5.3.0-dev.20231117 → 5.3.0-dev.20231119

package/src/programmers/internal/check_array_length.ts

@@ -1,47 +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,51 +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),
+        })),
+      );

package/src/programmers/internal/check_dynamic_key.ts

@@ -1,178 +1,175 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-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: IProject) =>
-    (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) => {
-    return [
-        ...(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 { IProject } from "../../transformers/IProject";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+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: IProject) =>
+  (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) => {
+  return [
+    ...(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));
+};