typia 7.0.0-dev.20241003 → 7.0.0-dev.20241007

package/src/programmers/internal/check_dynamic_key.ts

@@ -1,203 +1,201 @@
-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";
-
-/**
- * @internal
- */
-export const check_dynamic_key = (props: {
-  context: ITypiaContext;
-  importer: FunctionImporter;
-  metadata: Metadata;
-  input: ts.Expression;
-}): ts.Expression => {
-  // IF PURE STRING EXISTS, THEN SKIP VALIDATION
-  if (
-    (props.metadata.atomics.length !== 0 &&
-      props.metadata.atomics.some(
-        (a) =>
-          a.type === "string" &&
-          a.tags.filter((row) => row.every((t) => t.validate !== undefined))
-            .length === 0,
-      )) ||
-    (props.metadata.natives.length !== 0 &&
-      props.metadata.natives.some((type) => type === "String"))
-  )
-    return ts.factory.createTrue();
-
-  const conditions: ts.Expression[] = [];
-
-  // NULLISH COALESCING
-  if (props.metadata.nullable === true)
-    conditions.push(
-      ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("null"),
-        props.input,
-      ),
-    );
-  if (props.metadata.isRequired() === false)
-    conditions.push(
-      ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("undefined"),
-        props.input,
-      ),
-    );
-
-  // ATOMICS
-  for (const atom of props.metadata.atomics)
-    if (atom.type === "boolean")
-      conditions.push(
-        ts.factory.createLogicalOr(
-          ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("false"),
-            props.input,
-          ),
-          ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("true"),
-            props.input,
-          ),
-        ),
-      );
-    else if (atom.type === "bigint")
-      conditions.push(
-        ts.factory.createLogicalAnd(
-          ts.factory.createCallExpression(
-            props.importer.use("is_bigint_string"),
-            undefined,
-            [props.input],
-          ),
-          atomist(
-            check_bigint({
-              context: props.context,
-              atomic: atom,
-              input: ts.factory.createCallExpression(
-                ts.factory.createIdentifier("BigInt"),
-                undefined,
-                [props.input],
-              ),
-            }),
-          ),
-        ),
-      );
-    else if (atom.type === "number")
-      conditions.push(
-        atomist(
-          check_number({
-            context: props.context,
-            numeric: true,
-            atomic: atom,
-            input: ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Number"),
-              undefined,
-              [props.input],
-            ),
-          }),
-        ),
-      );
-    else
-      conditions.push(
-        atomist(
-          check_string({
-            context: props.context,
-            atomic: atom,
-            input: props.input,
-          }),
-        ),
-      );
-
-  // CONSTANTS
-  for (const constant of props.metadata.constants)
-    for (const { value } of constant.values)
-      conditions.push(
-        ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral(String(value)),
-          props.input,
-        ),
-      );
-
-  // TEMPLATES
-  if (!!props.metadata.templates.length)
-    conditions.push(
-      atomist(
-        check_template({
-          templates: props.metadata.templates,
-          input: props.input,
-        }),
-      ),
-    );
-
-  // NATIVES
-  for (const native of props.metadata.natives)
-    if (native === "Boolean")
-      conditions.push(
-        ts.factory.createLogicalOr(
-          ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("false"),
-            props.input,
-          ),
-          ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("true"),
-            props.input,
-          ),
-        ),
-      );
-    else if (native === "BigInt")
-      conditions.push(
-        ts.factory.createCallExpression(
-          props.importer.use("is_bigint_string"),
-          undefined,
-          [props.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,
-                [props.input],
-              ),
-            ],
-          ),
-        ),
-      );
-
-  return conditions.length === 0
-    ? ts.factory.createTrue()
-    : conditions.length === 1
-      ? conditions[0]!
-      : conditions.reduce(ts.factory.createLogicalOr);
-};
-
-/**
- * @internal
- */
-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 { 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";
+
+/**
+ * @internal
+ */
+export const check_dynamic_key = (props: {
+  context: ITypiaContext;
+  metadata: Metadata;
+  input: ts.Expression;
+}): ts.Expression => {
+  // IF PURE STRING EXISTS, THEN SKIP VALIDATION
+  if (
+    (props.metadata.atomics.length !== 0 &&
+      props.metadata.atomics.some(
+        (a) =>
+          a.type === "string" &&
+          a.tags.filter((row) => row.every((t) => t.validate !== undefined))
+            .length === 0,
+      )) ||
+    (props.metadata.natives.length !== 0 &&
+      props.metadata.natives.some((type) => type === "String"))
+  )
+    return ts.factory.createTrue();
+
+  const conditions: ts.Expression[] = [];
+
+  // NULLISH COALESCING
+  if (props.metadata.nullable === true)
+    conditions.push(
+      ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("null"),
+        props.input,
+      ),
+    );
+  if (props.metadata.isRequired() === false)
+    conditions.push(
+      ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("undefined"),
+        props.input,
+      ),
+    );
+
+  // ATOMICS
+  for (const atom of props.metadata.atomics)
+    if (atom.type === "boolean")
+      conditions.push(
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("false"),
+            props.input,
+          ),
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("true"),
+            props.input,
+          ),
+        ),
+      );
+    else if (atom.type === "bigint")
+      conditions.push(
+        ts.factory.createLogicalAnd(
+          ts.factory.createCallExpression(
+            props.context.importer.internal("isBigintString"),
+            undefined,
+            [props.input],
+          ),
+          atomist(
+            check_bigint({
+              context: props.context,
+              atomic: atom,
+              input: ts.factory.createCallExpression(
+                ts.factory.createIdentifier("BigInt"),
+                undefined,
+                [props.input],
+              ),
+            }),
+          ),
+        ),
+      );
+    else if (atom.type === "number")
+      conditions.push(
+        atomist(
+          check_number({
+            context: props.context,
+            numeric: true,
+            atomic: atom,
+            input: ts.factory.createCallExpression(
+              ts.factory.createIdentifier("Number"),
+              undefined,
+              [props.input],
+            ),
+          }),
+        ),
+      );
+    else
+      conditions.push(
+        atomist(
+          check_string({
+            context: props.context,
+            atomic: atom,
+            input: props.input,
+          }),
+        ),
+      );
+
+  // CONSTANTS
+  for (const constant of props.metadata.constants)
+    for (const { value } of constant.values)
+      conditions.push(
+        ts.factory.createStrictEquality(
+          ts.factory.createStringLiteral(String(value)),
+          props.input,
+        ),
+      );
+
+  // TEMPLATES
+  if (!!props.metadata.templates.length)
+    conditions.push(
+      atomist(
+        check_template({
+          templates: props.metadata.templates,
+          input: props.input,
+        }),
+      ),
+    );
+
+  // NATIVES
+  for (const native of props.metadata.natives)
+    if (native === "Boolean")
+      conditions.push(
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("false"),
+            props.input,
+          ),
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("true"),
+            props.input,
+          ),
+        ),
+      );
+    else if (native === "BigInt")
+      conditions.push(
+        ts.factory.createCallExpression(
+          props.context.importer.internal("isBigintString"),
+          undefined,
+          [props.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,
+                [props.input],
+              ),
+            ],
+          ),
+        ),
+      );
+
+  return conditions.length === 0
+    ? ts.factory.createTrue()
+    : conditions.length === 1
+      ? conditions[0]!
+      : conditions.reduce(ts.factory.createLogicalOr);
+};
+
+/**
+ * @internal
+ */
+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));