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

package/src/programmers/internal/check_string.ts

@@ -11,38 +11,39 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
 /**
  * @internal
  */
-export const check_string =
-  (project: ITypiaContext) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] =
-      check_string_type_tags(project)(atomic)(input);
-    return {
-      expected: atomic.getName(),
-      expression: ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("string"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-      conditions,
-    };
+export const check_string = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(props);
+  return {
+    expected: props.atomic.getName(),
+    expression: ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("string"),
+      ts.factory.createTypeOfExpression(props.input),
+    ),
+    conditions,
   };
+};
 
 /**
  * @internal
  */
-const check_string_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: `string & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.transformer)(tag.validate!)
-          )(input),
-        })),
-      );
+const check_string_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: `string & ${tag.name}`,
+        expression: (
+          tag.predicate ??
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
+        )(props.input),
+      })),
+    );

package/src/programmers/internal/check_template.ts

@@ -8,39 +8,41 @@ import { template_to_pattern } from "./template_to_pattern";
 /**
  * @internal
  */
-export const check_template =
-  (templates: MetadataTemplate[]) =>
-  (input: ts.Expression): ICheckEntry => {
-    // TYPEOF STRING & TAGS
-    const conditions: ts.Expression[] = [
-      ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("string"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-    ];
+export const check_template = (props: {
+  templates: MetadataTemplate[];
+  input: ts.Expression;
+}): ICheckEntry => {
+  // TYPEOF STRING & TAGS
+  const conditions: ts.Expression[] = [
+    ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("string"),
+      ts.factory.createTypeOfExpression(props.input),
+    ),
+  ];
 
-    // TEMPLATES
-    const internal: ts.Expression[] = templates.map((tpl) =>
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          `RegExp(/${template_to_pattern(true)(tpl.row)}/).test`,
-        ),
-        undefined,
-        [input],
+  // TEMPLATES
+  const internal: ts.Expression[] = props.templates.map((tpl) =>
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier(
+        `RegExp(/${template_to_pattern({
+          top: true,
+          template: tpl.row,
+        })}/).test`,
       ),
-    );
-    conditions.push(
-      internal.length === 1
-        ? internal[0]!
-        : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
-    );
+      undefined,
+      [props.input],
+    ),
+  );
+  conditions.push(
+    internal.length === 1
+      ? internal[0]!
+      : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
+  );
 
-    // COMBINATION
-    return {
-      expression: conditions.reduce((x, y) =>
-        ts.factory.createLogicalAnd(x, y),
-      ),
-      conditions: [],
-      expected: templates.map((tpl) => tpl.getName()).join(" | "),
-    };
+  // COMBINATION
+  return {
+    expression: conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+    conditions: [],
+    expected: props.templates.map((tpl) => tpl.getName()).join(" | "),
   };
+};