@typia/core 12.0.0-dev.20260225

package/src/programmers/iterate/check_dynamic_key.ts

@@ -0,0 +1,195 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_bigint } from "./check_bigint";
+import { check_number } from "./check_number";
+import { check_string } from "./check_string";
+import { check_template } from "./check_template";
+
+/** @internal */
+export const check_dynamic_key = (props: {
+  context: ITypiaContext;
+  metadata: MetadataSchema;
+  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((native) => native.name === "String"))
+  )
+    return ts.factory.createTrue();
+
+  const conditions: ts.Expression[] = [];
+
+  // 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.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("false"),
+            props.input,
+          ),
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("true"),
+            props.input,
+          ),
+        ),
+      );
+    else if (atom.type === "bigint")
+      conditions.push(
+        ts.factory.createLogicalAnd(
+          ts.factory.createCallExpression(
+            props.context.importer.internal("isBigintString"),
+            undefined,
+            [props.input],
+          ),
+          atomist(
+            check_bigint({
+              context: props.context,
+              atomic: atom,
+              input: ts.factory.createCallExpression(
+                ts.factory.createIdentifier("BigInt"),
+                undefined,
+                [props.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 props.metadata.constants)
+    for (const { value } of constant.values)
+      conditions.push(
+        ts.factory.createStrictEquality(
+          ts.factory.createStringLiteral(String(value)),
+          props.input,
+        ),
+      );
+
+  // TEMPLATES
+  if (!!props.metadata.templates.length)
+    conditions.push(
+      atomist(
+        check_template({
+          templates: props.metadata.templates,
+          input: props.input,
+        }),
+      ),
+    );
+
+  // NATIVES
+  for (const native of props.metadata.natives)
+    if (native.name === "Boolean")
+      conditions.push(
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("false"),
+            props.input,
+          ),
+          ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("true"),
+            props.input,
+          ),
+        ),
+      );
+    else if (native.name === "BigInt")
+      conditions.push(
+        ts.factory.createCallExpression(
+          props.context.importer.internal("isBigintString"),
+          undefined,
+          [props.input],
+        ),
+      );
+    else if (native.name === "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,
+                [props.input],
+              ),
+            ],
+          ),
+        ),
+      );
+
+  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] : []),
+    ...(entry.conditions.length === 0
+      ? []
+      : [
+          entry.conditions
+            .map((set) =>
+              set
+                .map((s) => s.expression)
+                .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+            )
+            .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+        ]),
+  ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));

package/src/programmers/iterate/check_dynamic_properties.ts

@@ -0,0 +1,229 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+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,
+                    ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createArrayLiteralExpression(
+                          [
+                            ts.factory.createTemplateExpression(
+                              ts.factory.createTemplateHead("The property `"),
+                              [
+                                ts.factory.createTemplateSpan(
+                                  ts.factory.createIdentifier("key"),
+                                  ts.factory.createTemplateTail(
+                                    "` is not defined in the object type.",
+                                  ),
+                                ),
+                              ],
+                            ),
+                            ts.factory.createStringLiteral(""),
+                            ts.factory.createStringLiteral(
+                              "Please remove the property next time.",
+                            ),
+                          ],
+                          true,
+                        ),
+                        "join",
+                      ),
+                      undefined,
+                      [ts.factory.createStringLiteral("\n")],
+                    ),
+                  )
+                : 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/iterate/check_everything.ts

@@ -0,0 +1,21 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+/** @internal */
+export const check_everything = (array: ts.Expression) =>
+  ts.factory.createCallExpression(
+    IdentifierFactory.access(array, "every"),
+    undefined,
+    [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("flag", TypeFactory.keyword("boolean"))],
+        undefined,
+        undefined,
+        ts.factory.createIdentifier("flag"),
+      ),
+    ],
+  );

package/src/programmers/iterate/check_native.ts

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

package/src/programmers/iterate/check_number.ts

@@ -0,0 +1,105 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+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/iterate/check_object.ts

@@ -0,0 +1,71 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/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/iterate/check_string.ts

@@ -0,0 +1,43 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+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),
+      })),
+    );