typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/programmers/internal/check_bigint.ts

@@ -11,39 +11,39 @@ 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,
-    };
+export const check_bigint = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_bigint_type_tags(props);
+  return {
+    expected: props.atomic.getName(),
+    expression: ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("bigint"),
+      ts.factory.createTypeOfExpression(props.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),
-        })),
-      );
+const check_bigint_type_tags = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry.ICondition[][] =>
+  props.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(props.context.transformer, tag.validate!)
+        )(props.input),
+      })),
+    );

package/src/programmers/internal/check_dynamic_key.ts

@@ -11,152 +11,181 @@ 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();
+/**
+ * @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[] = [];
+  const conditions: ts.Expression[] = [];
 
-    // NULLISH COALESCING
-    if (metadata.nullable === true)
+  // 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.createStrictEquality(
-          ts.factory.createStringLiteral("null"),
-          input,
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("false"),
+            props.input,
+          ),
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("true"),
+            props.input,
+          ),
         ),
       );
-    if (metadata.isRequired() === false)
+    else if (atom.type === "bigint")
       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],
-                ),
-              ),
-            ),
+        ts.factory.createLogicalAnd(
+          ts.factory.createCallExpression(
+            props.importer.use("is_bigint_string"),
+            undefined,
+            [props.input],
           ),
-        );
-      else if (atom.type === "number")
-        conditions.push(
           atomist(
-            check_number(project, true)(atom)(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Number"),
+            check_bigint({
+              context: props.context,
+              atomic: atom,
+              input: ts.factory.createCallExpression(
+                ts.factory.createIdentifier("BigInt"),
                 undefined,
-                [input],
+                [props.input],
               ),
-            ),
+            }),
           ),
-        );
-      else conditions.push(atomist(check_string(project)(atom)(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 metadata.constants)
-      for (const { value } of constant.values)
-        conditions.push(
-          ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral(String(value)),
-            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 (!!metadata.templates.length)
-      conditions.push(atomist(check_template(metadata.templates)(input)));
+  // TEMPLATES
+  if (!!props.metadata.templates.length)
+    conditions.push(
+      atomist(
+        check_template({
+          templates: props.metadata.templates,
+          input: props.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,
-            ),
+  // 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,
           ),
-        );
-      else if (native === "BigInt")
-        conditions.push(
+          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(
-            importer.use("is_bigint_string"),
+            ts.factory.createIdentifier("Number.isNaN"),
             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],
-                ),
-              ],
-            ),
+            [
+              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);
-  };
+  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] : []),