typia 9.7.2 → 10.0.0-dev.20251107

package/src/programmers/helpers/ProtobufWire.ts

@@ -1,34 +1,34 @@
-export const enum ProtobufWire {
-  /**
-   * - Integers
-   * - Bool
-   * - Enum
-   */
-  VARIANT = 0,
-
-  /**
-   * - Fixed64
-   * - Sfixed64
-   * - Double
-   */
-  I64 = 1,
-
-  /**
-   * - String
-   * - Bytes
-   * - Mebedded messages
-   * - Packed repeated fields
-   */
-  LEN = 2,
-
-  START_GROUP = 3,
-
-  END_GROUP = 4,
-
-  /**
-   * - Fixed
-   * - Sfixed32
-   * - Float
-   */
-  I32 = 5,
-}
+export const enum ProtobufWire {
+  /**
+   * - Integers
+   * - Bool
+   * - Enum
+   */
+  VARIANT = 0,
+
+  /**
+   * - Fixed64
+   * - Sfixed64
+   * - Double
+   */
+  I64 = 1,
+
+  /**
+   * - String
+   * - Bytes
+   * - Mebedded messages
+   * - Packed repeated fields
+   */
+  LEN = 2,
+
+  START_GROUP = 3,
+
+  END_GROUP = 4,
+
+  /**
+   * - Fixed
+   * - Sfixed32
+   * - Float
+   */
+  I32 = 5,
+}

package/src/programmers/internal/check_array_length.ts

@@ -1,43 +1,43 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/** @internal */
-export const check_array_length = (props: {
-  context: ITypiaContext;
-  array: MetadataArray;
-  input: ts.Expression;
-}): ICheckEntry => {
-  const conditions: ICheckEntry.ICondition[][] = check_array_type_tags(props);
-  return {
-    expected: props.array.getName(),
-    expression: null,
-    conditions,
-  };
-};
-
-/** @internal */
-const check_array_type_tags = (props: {
-  context: ITypiaContext;
-  array: MetadataArray;
-  input: ts.Expression;
-}): ICheckEntry.ICondition[][] =>
-  props.array.tags
-    .map((row) => row.filter((tag) => !!tag.validate))
-    .filter((row) => !!row.length)
-    .map((row) =>
-      row.map((tag) => ({
-        expected: `Array<> & ${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 { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/** @internal */
+export const check_array_length = (props: {
+  context: ITypiaContext;
+  array: MetadataArray;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_array_type_tags(props);
+  return {
+    expected: props.array.getName(),
+    expression: null,
+    conditions,
+  };
+};
+
+/** @internal */
+const check_array_type_tags = (props: {
+  context: ITypiaContext;
+  array: MetadataArray;
+  input: ts.Expression;
+}): ICheckEntry.ICondition[][] =>
+  props.array.tags
+    .map((row) => row.filter((tag) => !!tag.validate))
+    .filter((row) => !!row.length)
+    .map((row) =>
+      row.map((tag) => ({
+        expected: `Array<> & ${tag.name}`,
+        expression: ExpressionFactory.transpile({
+          transformer: props.context.transformer,
+          importer: props.context.importer,
+          script: tag.validate!,
+        })(props.input),
+      })),
+    );

package/src/programmers/internal/check_bigint.ts

@@ -1,46 +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_bigint = (props: {
-  context: ITypiaContext;
-  atomic: MetadataAtomic;
-  input: ts.Expression;
-}): ICheckEntry => {
-  const conditions: ICheckEntry.ICondition[][] = check_bigint_type_tags(props);
-  return {
-    expected: props.atomic.getName(),
-    expression: ts.factory.createStrictEquality(
-      ts.factory.createStringLiteral("bigint"),
-      ts.factory.createTypeOfExpression(props.input),
-    ),
-    conditions,
-  };
-};
-
-/** @internal */
-const check_bigint_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: `bigint & ${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_bigint = (props: {
+  context: ITypiaContext;
+  atomic: MetadataAtomic;
+  input: ts.Expression;
+}): ICheckEntry => {
+  const conditions: ICheckEntry.ICondition[][] = check_bigint_type_tags(props);
+  return {
+    expected: props.atomic.getName(),
+    expression: ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("bigint"),
+      ts.factory.createTypeOfExpression(props.input),
+    ),
+    conditions,
+  };
+};
+
+/** @internal */
+const check_bigint_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: `bigint & ${tag.name}`,
+        expression: ExpressionFactory.transpile({
+          transformer: props.context.transformer,
+          importer: props.context.importer,
+          script: tag.validate!,
+        })(props.input),
+      })),
+    );

package/src/programmers/internal/check_dynamic_key.ts

@@ -1,197 +1,197 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-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: Metadata;
-  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));
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+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: Metadata;
+  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));