typia 9.7.1 → 10.0.0-dev.20251107

package/src/programmers/internal/check_number.ts

@@ -1,112 +1,108 @@
-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: ExpressionFactory.transpile({
-          transformer: props.context.transformer,
-          importer: props.context.importer,
-          script: 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: ExpressionFactory.transpile({
+          transformer: props.context.transformer,
+          importer: props.context.importer,
+          script: tag.validate!,
+        })(props.input),
+      })),
+    ]);

package/src/programmers/internal/check_object.ts

@@ -1,78 +1,72 @@
-import ts from "typescript";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_dynamic_properties } from "./check_dynamic_properties";
-import { check_everything } from "./check_everything";
-
-/**
- * @internal
- */
-export const check_object = (props: {
-  config: check_object.IConfig;
-  context: ITypiaContext;
-  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 (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: props.config,
-      context: props.context,
-      input: props.input,
-      regular,
-      dynamic,
-    }),
-  );
-  return reduce({
-    config: props.config,
-    expressions: flags,
-  });
-};
-
-/**
- * @internal
- */
-export namespace check_object {
-  export interface IConfig {
-    equals: boolean;
-    assert: boolean;
-    undefined: boolean;
-    halt?: undefined | ((exp: ts.Expression) => ts.Expression);
-    reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
-    positive: ts.Expression;
-    superfluous: (
-      value: ts.Expression,
-      description?: ts.Expression,
-    ) => ts.Expression;
-    entries?: undefined | ts.Identifier;
-  }
-}
-
-/**
- * @internal
- */
-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),
-      );
+import ts from "typescript";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_properties } from "./check_dynamic_properties";
+import { check_everything } from "./check_everything";
+
+/** @internal */
+export const check_object = (props: {
+  config: check_object.IConfig;
+  context: ITypiaContext;
+  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 (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: props.config,
+      context: props.context,
+      input: props.input,
+      regular,
+      dynamic,
+    }),
+  );
+  return reduce({
+    config: props.config,
+    expressions: flags,
+  });
+};
+
+/** @internal */
+export namespace check_object {
+  export interface IConfig {
+    equals: boolean;
+    assert: boolean;
+    undefined: boolean;
+    halt?: undefined | ((exp: ts.Expression) => ts.Expression);
+    reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
+    positive: ts.Expression;
+    superfluous: (
+      value: ts.Expression,
+      description?: ts.Expression,
+    ) => ts.Expression;
+    entries?: undefined | ts.Identifier;
+  }
+}
+
+/** @internal */
+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),
+      );

package/src/programmers/internal/check_string.ts

@@ -1,50 +1,46 @@
-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";
-
-/**
- * @internal
- */
-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 = (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: ExpressionFactory.transpile({
-          transformer: props.context.transformer,
-          importer: props.context.importer,
-          script: 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";
+
+/** @internal */
+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 = (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: ExpressionFactory.transpile({
+          transformer: props.context.transformer,
+          importer: props.context.importer,
+          script: tag.validate!,
+        })(props.input),
+      })),
+    );

package/src/programmers/internal/check_template.ts

@@ -1,48 +1,46 @@
-import ts from "typescript";
-
-import { MetadataTemplate } from "../../schemas/metadata/MetadataTemplate";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-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[] = props.templates.map((tpl) =>
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier(
-        `RegExp(/${template_to_pattern({
-          top: true,
-          template: tpl.row,
-        })}/).test`,
-      ),
-      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: props.templates.map((tpl) => tpl.getName()).join(" | "),
-  };
-};
+import ts from "typescript";
+
+import { MetadataTemplate } from "../../schemas/metadata/MetadataTemplate";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { template_to_pattern } from "./template_to_pattern";
+
+/** @internal */
+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[] = props.templates.map((tpl) =>
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier(
+        `RegExp(/${template_to_pattern({
+          top: true,
+          template: tpl.row,
+        })}/).test`,
+      ),
+      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: props.templates.map((tpl) => tpl.getName()).join(" | "),
+  };
+};