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

package/src/programmers/internal/check_dynamic_properties.ts

@@ -1,212 +1,208 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_dynamic_key } from "./check_dynamic_key";
-import { check_everything } from "./check_everything";
-import { check_object } from "./check_object";
-
-/**
- * @internal
- */
-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(
-                props.regular.filter((r) => r.meta.isRequired()).length,
-              ),
-              ExpressionFactory.number(props.regular.length),
-            ],
-          )
-      : null;
-  if (
-    left !== null &&
-    props.config.undefined === false &&
-    props.regular.every((r) => r.meta.isRequired())
-  )
-    return left;
-
-  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,
-            [props.input],
-          ),
-          props.config.assert ? "every" : "map",
-        ),
-        undefined,
-        [check_dynamic_property(props)],
-      );
-  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");
-
-  const statements: ts.Statement[] = [];
-  const add = (expression: ts.Expression, output: ts.Expression) =>
-    statements.push(
-      ts.factory.createIfStatement(
-        expression,
-        ts.factory.createReturnStatement(output),
-      ),
-    );
-  const broken = { value: false };
-
-  // 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,
-    );
-
-  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(
-      ts.factory.createArrayLiteralExpression(
-        regular.map((entry) =>
-          ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
-        ),
-      ),
-      "some",
-    ),
-    undefined,
-    [
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("prop")],
-        undefined,
-        undefined,
-        ts.factory.createStrictEquality(
-          ts.factory.createIdentifier("key"),
-          ts.factory.createIdentifier("prop"),
-        ),
-      ),
-    ],
-  );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_key } from "./check_dynamic_key";
+import { check_everything } from "./check_everything";
+import { check_object } from "./check_object";
+
+/**
+ * @internal
+ */
+export const check_dynamic_properties = (props: {
+  config: check_object.IConfig;
+  context: ITypiaContext;
+  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.context.importer.internal("isBetween"),
+            [],
+            [
+              length,
+              ExpressionFactory.number(
+                props.regular.filter((r) => r.meta.isRequired()).length,
+              ),
+              ExpressionFactory.number(props.regular.length),
+            ],
+          )
+      : null;
+  if (
+    left !== null &&
+    props.config.undefined === false &&
+    props.regular.every((r) => r.meta.isRequired())
+  )
+    return left;
+
+  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,
+            [props.input],
+          ),
+          props.config.assert ? "every" : "map",
+        ),
+        undefined,
+        [check_dynamic_property(props)],
+      );
+  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;
+  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");
+
+  const statements: ts.Statement[] = [];
+  const add = (expression: ts.Expression, output: ts.Expression) =>
+    statements.push(
+      ts.factory.createIfStatement(
+        expression,
+        ts.factory.createReturnStatement(output),
+      ),
+    );
+  const broken = { value: false };
+
+  // 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,
+    );
+
+  for (const entry of props.dynamic) {
+    const condition: ts.Expression = check_dynamic_key({
+      context: props.context,
+      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(
+      ts.factory.createArrayLiteralExpression(
+        regular.map((entry) =>
+          ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
+        ),
+      ),
+      "some",
+    ),
+    undefined,
+    [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("prop")],
+        undefined,
+        undefined,
+        ts.factory.createStrictEquality(
+          ts.factory.createIdentifier("key"),
+          ts.factory.createIdentifier("prop"),
+        ),
+      ),
+    ],
+  );

package/src/programmers/internal/check_number.ts

@@ -1,111 +1,111 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { OptionPredicator } from "../helpers/OptionPredicator";
-
-/**
- * @internal
- */
-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],
-              ),
-            )
-          : 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 = (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 === "maximum" || tag.kind === "exclusiveMaximum") &&
-                  typeof tag.value === "number",
-              ))
-          ? []
-          : [
-              {
-                expected: "number",
-                expression: props.addition!,
-              },
-            ]),
-      ...row.map((tag) => ({
-        expected: `number & ${tag.name}`,
-        expression: (
-          tag.predicate ??
-          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
-        )(props.input),
-      })),
-    ]);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { OptionPredicator } from "../helpers/OptionPredicator";
+
+/**
+ * @internal
+ */
+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],
+              ),
+            )
+          : 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 = (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 === "maximum" || tag.kind === "exclusiveMaximum") &&
+                  typeof tag.value === "number",
+              ))
+          ? []
+          : [
+              {
+                expected: "number",
+                expression: props.addition!,
+              },
+            ]),
+      ...row.map((tag) => ({
+        expected: `number & ${tag.name}`,
+        expression: (
+          tag.predicate ??
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
+        )(props.input),
+      })),
+    ]);