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

package/src/programmers/internal/check_dynamic_properties.ts

@@ -15,176 +15,176 @@ import { check_object } from "./check_object";
 /**
  * @internal
  */
-export const check_dynamic_properties =
-  (props: check_object.IProps) =>
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter) =>
-  (
-    input: ts.Expression,
-    regular: IExpressionEntry<ts.Expression>[],
-    dynamic: IExpressionEntry<ts.Expression>[],
-  ): ts.Expression => {
-    const length = IdentifierFactory.access(
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("Object.keys"),
-        undefined,
-        [input],
-      ),
-    )("length");
-    const left: ts.Expression | null =
-      props.equals === true && dynamic.length === 0
-        ? props.undefined === true || regular.every((r) => r.meta.isRequired())
-          ? ts.factory.createStrictEquality(
+export const check_dynamic_properties = (props: {
+  config: check_object.IConfig;
+  context: ITypiaContext;
+  importer: FunctionImporter;
+  regular: IExpressionEntry<ts.Expression>[];
+  dynamic: IExpressionEntry<ts.Expression>[];
+  input: ts.Expression;
+}): ts.Expression => {
+  const length = IdentifierFactory.access(
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("Object.keys"),
+      undefined,
+      [props.input],
+    ),
+    "length",
+  );
+  const left: ts.Expression | null =
+    props.config.equals === true && props.dynamic.length === 0
+      ? props.config.undefined === true ||
+        props.regular.every((r) => r.meta.isRequired())
+        ? ts.factory.createStrictEquality(
+            ExpressionFactory.number(
+              props.regular.filter((r) => r.meta.isRequired()).length,
+            ),
+            length,
+          )
+        : ts.factory.createCallExpression(
+            props.importer.use("is_between"),
+            [],
+            [
+              length,
               ExpressionFactory.number(
-                regular.filter((r) => r.meta.isRequired()).length,
+                props.regular.filter((r) => r.meta.isRequired()).length,
               ),
-              length,
-            )
-          : ts.factory.createCallExpression(
-              importer.use("is_between"),
-              [],
-              [
-                length,
-                ExpressionFactory.number(
-                  regular.filter((r) => r.meta.isRequired()).length,
-                ),
-                ExpressionFactory.number(regular.length),
-              ],
-            )
-        : null;
-    if (
-      props.undefined === false &&
-      left !== null &&
-      regular.every((r) => r.meta.isRequired())
-    )
-      return left;
+              ExpressionFactory.number(props.regular.length),
+            ],
+          )
+      : null;
+  if (
+    left !== null &&
+    props.config.undefined === false &&
+    props.regular.every((r) => r.meta.isRequired())
+  )
+    return left;
 
-    const criteria = props.entries
-      ? ts.factory.createCallExpression(props.entries, undefined, [
+  const criteria: ts.CallExpression = props.config.entries
+    ? ts.factory.createCallExpression(props.config.entries, undefined, [
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.keys"),
+          undefined,
+          [props.input],
+        ),
+        check_dynamic_property(props),
+      ])
+    : ts.factory.createCallExpression(
+        IdentifierFactory.access(
           ts.factory.createCallExpression(
             ts.factory.createIdentifier("Object.keys"),
             undefined,
-            [input],
-          ),
-          check_dynamic_property(props)(project)(importer)(
-            input,
-            regular,
-            dynamic,
+            [props.input],
           ),
-        ])
-      : ts.factory.createCallExpression(
-          IdentifierFactory.access(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Object.keys"),
-              undefined,
-              [input],
-            ),
-          )(props.assert ? "every" : "map"),
-          undefined,
-          [
-            check_dynamic_property(props)(project)(importer)(
-              input,
-              regular,
-              dynamic,
-            ),
-          ],
-        );
-    const right: ts.Expression = (props.halt || ((elem) => elem))(
-      props.assert ? criteria : check_everything(criteria),
-    );
-    return left
-      ? (props.undefined
-          ? ts.factory.createLogicalOr
-          : ts.factory.createLogicalAnd)(left, right)
-      : right;
-  };
-
-const check_dynamic_property =
-  (props: check_object.IProps) =>
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter) =>
-  (
-    input: ts.Expression,
-    regular: IExpressionEntry<ts.Expression>[],
-    dynamic: IExpressionEntry<ts.Expression>[],
-  ) => {
-    //----
-    // IF CONDITIONS
-    //----
-    // PREPARE ASSETS
-    const key = ts.factory.createIdentifier("key");
-    const value = ts.factory.createIdentifier("value");
-
-    const statements: ts.Statement[] = [];
-    const add = (exp: ts.Expression, output: ts.Expression) =>
-      statements.push(
-        ts.factory.createIfStatement(
-          exp,
-          ts.factory.createReturnStatement(output),
+          props.config.assert ? "every" : "map",
         ),
+        undefined,
+        [check_dynamic_property(props)],
       );
-    const broken = { value: false };
+  const right: ts.Expression = (props.config.halt || ((elem) => elem))(
+    props.config.assert ? criteria : check_everything(criteria),
+  );
+  return left
+    ? (props.config.undefined
+        ? ts.factory.createLogicalOr
+        : ts.factory.createLogicalAnd)(left, right)
+    : right;
+};
+
+/**
+ * @internal
+ */
+const check_dynamic_property = (props: {
+  config: check_object.IConfig;
+  context: ITypiaContext;
+  importer: FunctionImporter;
+  regular: IExpressionEntry<ts.Expression>[];
+  dynamic: IExpressionEntry<ts.Expression>[];
+  input: ts.Expression;
+}) => {
+  //----
+  // IF CONDITIONS
+  //----
+  // PREPARE ASSETS
+  const key = ts.factory.createIdentifier("key");
+  const value = ts.factory.createIdentifier("value");
 
-    // GATHER CONDITIONS
-    if (regular.length) add(is_regular_property(regular), props.positive);
+  const statements: ts.Statement[] = [];
+  const add = (expression: ts.Expression, output: ts.Expression) =>
     statements.push(
-      StatementFactory.constant(
-        "value",
-        ts.factory.createElementAccessExpression(input, key),
+      ts.factory.createIfStatement(
+        expression,
+        ts.factory.createReturnStatement(output),
       ),
     );
-    if (props.undefined === true)
-      add(
-        ts.factory.createStrictEquality(
-          ts.factory.createIdentifier("undefined"),
-          value,
-        ),
-        props.positive,
-      );
+  const broken = { value: false };
 
-    for (const entry of dynamic) {
-      const condition: ts.Expression = check_dynamic_key(project)(importer)(
-        key,
-        entry.key,
-      );
-      if (condition.kind === ts.SyntaxKind.TrueKeyword) {
-        statements.push(ts.factory.createReturnStatement(entry.expression));
-        broken.value = true;
-        break;
-      } else add(condition, entry.expression);
-    }
-
-    //----
-    // FUNCTION BODY
-    //----
-    // CLOSURE BLOCK
-    const block: ts.Block = ts.factory.createBlock(
-      [
-        ...statements,
-        ...(broken.value
-          ? []
-          : [
-              ts.factory.createReturnStatement(
-                props.equals === true
-                  ? props.superfluous(value)
-                  : props.positive,
-              ),
-            ]),
-      ],
-      true,
+  // GATHER CONDITIONS
+  if (props.regular.length)
+    add(is_regular_property(props.regular), props.config.positive);
+  statements.push(
+    StatementFactory.constant({
+      name: "value",
+      value: ts.factory.createElementAccessExpression(props.input, key),
+    }),
+  );
+  if (props.config.undefined === true)
+    add(
+      ts.factory.createStrictEquality(
+        ts.factory.createIdentifier("undefined"),
+        value,
+      ),
+      props.config.positive,
     );
 
-    // RETURNS
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("key")],
-      undefined,
-      undefined,
-      block,
-    );
-  };
+  for (const entry of props.dynamic) {
+    const condition: ts.Expression = check_dynamic_key({
+      context: props.context,
+      importer: props.importer,
+      metadata: entry.key,
+      input: key,
+    });
+    if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+      statements.push(ts.factory.createReturnStatement(entry.expression));
+      broken.value = true;
+      break;
+    } else add(condition, entry.expression);
+  }
+
+  //----
+  // FUNCTION BODY
+  //----
+  // CLOSURE BLOCK
+  const block: ts.Block = ts.factory.createBlock(
+    [
+      ...statements,
+      ...(broken.value
+        ? []
+        : [
+            ts.factory.createReturnStatement(
+              props.config.equals === true
+                ? props.config.superfluous(value)
+                : props.config.positive,
+            ),
+          ]),
+    ],
+    true,
+  );
+
+  // RETURNS
+  return ts.factory.createArrowFunction(
+    undefined,
+    undefined,
+    [IdentifierFactory.parameter("key")],
+    undefined,
+    undefined,
+    block,
+  );
+};
 
+/**
+ * @internal
+ */
 const is_regular_property = (regular: IExpressionEntry[]) =>
   ts.factory.createCallExpression(
     IdentifierFactory.access(
@@ -193,7 +193,8 @@ const is_regular_property = (regular: IExpressionEntry[]) =>
           ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
         ),
       ),
-    )("some"),
+      "some",
+    ),
     undefined,
     [
       ts.factory.createArrowFunction(

package/src/programmers/internal/check_everything.ts

@@ -8,7 +8,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
  */
 export const check_everything = (array: ts.Expression) =>
   ts.factory.createCallExpression(
-    IdentifierFactory.access(array)("every"),
+    IdentifierFactory.access(array, "every"),
     undefined,
     [
       ts.factory.createArrowFunction(

package/src/programmers/internal/check_native.ts

@@ -5,17 +5,23 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 /**
  * @internal
  */
-export const check_native = (type: string) => (input: ts.Expression) => {
-  const instanceOf = ExpressionFactory.isInstanceOf(type)(input);
-  return ATOMIC_LIKE.has(type)
+export const check_native = (props: {
+  type: string;
+  input: ts.Expression;
+}): ts.Expression => {
+  const instanceOf = ExpressionFactory.isInstanceOf(props.type, props.input);
+  return ATOMIC_LIKE.has(props.type)
     ? ts.factory.createLogicalOr(
         ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral(type.toLowerCase()),
-          ts.factory.createTypeOfExpression(input),
+          ts.factory.createStringLiteral(props.type.toLowerCase()),
+          ts.factory.createTypeOfExpression(props.input),
         ),
         instanceOf,
       )
     : instanceOf;
 };
 
+/**
+ * @internal
+ */
 const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

package/src/programmers/internal/check_number.ts

@@ -12,96 +12,100 @@ import { OptionPredicator } from "../helpers/OptionPredicator";
 /**
  * @internal
  */
-export const check_number =
-  (project: ITypiaContext, numeric: boolean) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const base = ts.factory.createStrictEquality(
-      ts.factory.createStringLiteral("number"),
-      ts.factory.createTypeOfExpression(input),
-    );
-    const addition: ts.Expression | null =
-      numeric === true
-        ? OptionPredicator.finite(project.options)
-          ? ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Number.isFinite"),
-              undefined,
-              [input],
+export const check_number = (props: {
+  numeric: boolean;
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const base: ts.BinaryExpression = ts.factory.createStrictEquality(
+    ts.factory.createStringLiteral("number"),
+    ts.factory.createTypeOfExpression(props.input),
+  );
+  const addition: ts.Expression | null =
+    props.numeric === true
+      ? OptionPredicator.finite(props.context.options)
+        ? ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Number.isFinite"),
+            undefined,
+            [props.input],
+          )
+        : OptionPredicator.numeric(props.context.options)
+          ? ts.factory.createLogicalNot(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Number.isNaN"),
+                undefined,
+                [props.input],
+              ),
             )
-          : OptionPredicator.numeric(project.options)
-            ? ts.factory.createLogicalNot(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("Number.isNaN"),
-                  undefined,
-                  [input],
-                ),
-              )
-            : null
-        : null;
-
-    const conditions: ICheckEntry.ICondition[][] =
-      check_numeric_type_tags(project)(atomic)(addition)(input);
-
-    return {
-      expected: atomic.getName(),
-      expression:
-        addition !== null && conditions.length === 0
-          ? ts.factory.createLogicalAnd(base, addition)
-          : base,
-      conditions,
-    };
+          : null
+      : null;
+  const conditions: ICheckEntry.ICondition[][] = check_numeric_type_tags({
+    context: props.context,
+    atomic: props.atomic,
+    input: props.input,
+    addition,
+  });
+  return {
+    expected: props.atomic.getName(),
+    expression:
+      addition !== null && conditions.length === 0
+        ? ts.factory.createLogicalAnd(base, addition)
+        : base,
+    conditions,
   };
+};
 
 /**
  * @internal
  */
-const check_numeric_type_tags =
-  (project: ITypiaContext) =>
-  (atomic: MetadataAtomic) =>
-  (addition: ts.Expression | null) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    atomic.tags
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) => [
-        ...(addition === null
-          ? []
-          : row.some(
-                (tag) =>
-                  tag.kind === "type" &&
-                  (tag.value === "int32" ||
-                    tag.value === "uint32" ||
-                    tag.value === "int64" ||
-                    tag.value === "uint64" ||
-                    tag.value === "float"),
-              ) ||
+const check_numeric_type_tags = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  addition: ts.Expression | null;
+  input: ts.Expression;
+}): ICheckEntry.ICondition[][] =>
+  props.atomic.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) => [
+      ...(props.addition === null
+        ? []
+        : row.some(
+              (tag) =>
+                tag.kind === "type" &&
+                (tag.value === "int32" ||
+                  tag.value === "uint32" ||
+                  tag.value === "int64" ||
+                  tag.value === "uint64" ||
+                  tag.value === "float"),
+            ) ||
+            row.some(
+              (tag) =>
+                tag.kind === "multipleOf" && typeof tag.value === "number",
+            ) ||
+            (row.some(
+              (tag) =>
+                (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
+                typeof tag.value === "number",
+            ) &&
               row.some(
                 (tag) =>
-                  tag.kind === "multipleOf" && typeof tag.value === "number",
-              ) ||
-              (row.some(
-                (tag) =>
-                  (tag.kind === "minimum" || tag.kind === "exclusiveMinimum") &&
+                  (tag.kind === "maximum" || tag.kind === "exclusiveMaximum") &&
                   typeof tag.value === "number",
-              ) &&
-                row.some(
-                  (tag) =>
-                    (tag.kind === "maximum" ||
-                      tag.kind === "exclusiveMaximum") &&
-                    typeof tag.value === "number",
-                ))
-            ? []
-            : [
-                {
-                  expected: "number",
-                  expression: addition!,
-                },
-              ]),
-        ...row.map((tag) => ({
-          expected: `number & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.transformer)(tag.validate!)
-          )(input),
-        })),
-      ]);
+              ))
+          ? []
+          : [
+              {
+                expected: "number",
+                expression: props.addition!,
+              },
+            ]),
+      ...row.map((tag) => ({
+        expected: `number & ${tag.name}`,
+        expression: (
+          tag.predicate ??
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
+        )(props.input),
+      })),
+    ]);

package/src/programmers/internal/check_object.ts

@@ -10,39 +10,49 @@ import { check_everything } from "./check_everything";
 /**
  * @internal
  */
-export const check_object =
-  (config: check_object.IProps) =>
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter) =>
-  (props: {
-    input: ts.Expression;
-    entries: IExpressionEntry<ts.Expression>[];
-  }) => {
-    // PREPARE ASSETS
-    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
-    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
-    const flags: ts.Expression[] = regular.map((entry) => entry.expression);
+export const check_object = (props: {
+  config: check_object.IConfig;
+  context: ITypiaContext;
+  importer: FunctionImporter;
+  input: ts.Expression;
+  entries: IExpressionEntry<ts.Expression>[];
+}) => {
+  // PREPARE ASSETS
+  const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+  const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+  const flags: ts.Expression[] = regular.map((entry) => entry.expression);
 
-    // REGULAR WITHOUT DYNAMIC PROPERTIES
-    if (config.equals === false && dynamic.length === 0)
-      return regular.length === 0 ? config.positive : reduce(config)(flags);
+  // REGULAR WITHOUT DYNAMIC PROPERTIES
+  if (props.config.equals === false && dynamic.length === 0)
+    return regular.length === 0
+      ? props.config.positive
+      : reduce({
+          config: props.config,
+          expressions: flags,
+        });
 
-    // CHECK DYNAMIC PROPERTIES
-    flags.push(
-      check_dynamic_properties(config)(project)(importer)(
-        props.input,
-        regular,
-        dynamic,
-      ),
-    );
-    return reduce(config)(flags);
-  };
+  // CHECK DYNAMIC PROPERTIES
+  flags.push(
+    check_dynamic_properties({
+      config: props.config,
+      context: props.context,
+      importer: props.importer,
+      input: props.input,
+      regular,
+      dynamic,
+    }),
+  );
+  return reduce({
+    config: props.config,
+    expressions: flags,
+  });
+};
 
 /**
  * @internal
  */
 export namespace check_object {
-  export interface IProps {
+  export interface IConfig {
     equals: boolean;
     assert: boolean;
     undefined: boolean;
@@ -57,8 +67,12 @@ export namespace check_object {
 /**
  * @internal
  */
-const reduce =
-  (props: check_object.IProps) => (expressions: ts.Expression[]) =>
-    props.assert
-      ? expressions.reduce(props.reduce)
-      : check_everything(ts.factory.createArrayLiteralExpression(expressions));
+const reduce = (props: {
+  config: check_object.IConfig;
+  expressions: ts.Expression[];
+}) =>
+  props.config.assert
+    ? props.expressions.reduce(props.config.reduce)
+    : check_everything(
+        ts.factory.createArrayLiteralExpression(props.expressions),
+      );