@typia/core 12.0.0-dev.20260225

package/src/programmers/helpers/HttpMetadataUtil.ts

@@ -0,0 +1,21 @@
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+
+export namespace HttpMetadataUtil {
+  export const atomics = (
+    metadata: MetadataSchema,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...metadata.atomics.map((a) => a.type),
+      ...metadata.constants.map((c) => c.type),
+      ...(metadata.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (metadata: MetadataSchema): boolean =>
+    atomics(metadata).size +
+      metadata.arrays.length +
+      metadata.tuples.length +
+      metadata.natives.length +
+      metadata.maps.length +
+      metadata.objects.length >
+    1;
+}

package/src/programmers/helpers/ICheckEntry.ts

@@ -0,0 +1,13 @@
+import ts from "typescript";
+
+export interface ICheckEntry {
+  expected: string;
+  expression: ts.Expression | null;
+  conditions: ICheckEntry.ICondition[][];
+}
+export namespace ICheckEntry {
+  export interface ICondition {
+    expected: string;
+    expression: ts.Expression;
+  }
+}

package/src/programmers/helpers/IExpressionEntry.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+
+export interface IExpressionEntry<
+  Expression extends ts.ConciseBody = ts.ConciseBody,
+> {
+  input: ts.Expression;
+  key: MetadataSchema;
+  meta: MetadataSchema;
+  expression: Expression;
+}

package/src/programmers/helpers/NotationJoiner.ts

@@ -0,0 +1,144 @@
+import { NamingConvention } from "@typia/utils";
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { metadata_to_pattern } from "../iterate/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace NotationJoiner {
+  export const object = (props: {
+    rename: (str: string) => string;
+    input: ts.Expression;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.ConciseBody => {
+    if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
+
+    const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+    const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
+    const literal = ts.factory.createObjectLiteralExpression(
+      regular.map((entry) => {
+        const str: string = props.rename(entry.key.getSoleLiteral()!);
+        return ts.factory.createPropertyAssignment(
+          NamingConvention.variable(str)
+            ? str
+            : ts.factory.createStringLiteral(str),
+          entry.expression,
+        );
+      }),
+      true,
+    );
+    if (dynamic.length === 0) return literal;
+
+    const key = ts.factory.createIdentifier("key");
+    const output = ts.factory.createIdentifier("output");
+
+    const statements: ts.Statement[] = [];
+    if (regular.length !== 0)
+      statements.push(
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              ts.factory.createArrayLiteralExpression(
+                regular.map((r) =>
+                  ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
+                ),
+              ),
+              "some",
+            ),
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("regular")],
+                undefined,
+                undefined,
+                ts.factory.createStrictEquality(
+                  ts.factory.createIdentifier("regular"),
+                  ts.factory.createIdentifier("key"),
+                ),
+              ),
+            ],
+          ),
+          ts.factory.createContinueStatement(),
+        ),
+      );
+    statements.push(
+      ...dynamic.map((entry) =>
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+              `RegExp(/${metadata_to_pattern({
+                top: true,
+                metadata: entry.key,
+              })}/).test`,
+            ),
+            undefined,
+            [key],
+          ),
+          ts.factory.createBlock([
+            ts.factory.createExpressionStatement(
+              ts.factory.createBinaryExpression(
+                ts.factory.createElementAccessExpression(output, key),
+                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                entry.expression,
+              ),
+            ),
+            ts.factory.createContinueStatement(),
+          ]),
+        ),
+      ),
+    );
+
+    return ts.factory.createBlock([
+      StatementFactory.constant({
+        name: "output",
+        value: ts.factory.createAsExpression(
+          literal,
+          TypeFactory.keyword("any"),
+        ),
+      }),
+      ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.entry({
+          key: "key",
+          value: "value",
+        }),
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.entries"),
+          undefined,
+          [props.input],
+        ),
+        ts.factory.createBlock(statements),
+      ),
+      ts.factory.createReturnStatement(output),
+    ]);
+  };
+
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
+    return ts.factory.createAsExpression(
+      ts.factory.createArrayLiteralExpression(
+        props.rest === null
+          ? props.elements
+          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
+        true,
+      ),
+      TypeFactory.keyword("any"),
+    );
+  };
+
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.Expression;
+  }) =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(props.input, "map"),
+      undefined,
+      [props.arrow],
+    );
+}

package/src/programmers/helpers/OptionPredicator.ts

@@ -0,0 +1,15 @@
+import { ITransformOptions } from "../../context/ITransformOptions";
+
+export namespace OptionPredicator {
+  export const numeric = (options: ITransformOptions): boolean =>
+    finite(options) || options.numeric === true;
+
+  export const functional = (options: ITransformOptions): boolean =>
+    options.functional === true;
+
+  export const finite = (options: ITransformOptions): boolean =>
+    options.finite === true;
+
+  export const undefined = (options: ITransformOptions): boolean =>
+    options.undefined !== false;
+}

package/src/programmers/helpers/ProtobufUtil.ts

@@ -0,0 +1,227 @@
+import { IMetadataTypeTag, ProtobufAtomic } from "@typia/interface";
+
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSchema } from "../../schemas/metadata/MetadataSchema";
+
+export namespace ProtobufUtil {
+  export const isStaticObject = (obj: MetadataObjectType): boolean =>
+    obj.properties.length >= 1 &&
+    obj.properties.every((p) => p.key.isSoleLiteral());
+
+  export const size = (meta: MetadataSchema): number =>
+    getAtomics(meta).size +
+    meta.arrays.length +
+    meta.tuples.length +
+    meta.natives.length +
+    meta.objects.length +
+    meta.maps.length;
+
+  export const getSequence = (tags: IMetadataTypeTag[]): number | null => {
+    const sequence = tags.find(
+      (t) =>
+        t.kind === "sequence" &&
+        typeof (t.schema as any)?.["x-protobuf-sequence"] === "number",
+    );
+    if (sequence === undefined) return null;
+    const value: number = Number(
+      (sequence.schema as any)["x-protobuf-sequence"],
+    );
+    return Number.isNaN(value) ? null : value;
+  };
+
+  export const isUnion = (meta: MetadataSchema): boolean => size(meta) > 1;
+
+  export const getAtomics = (
+    meta: MetadataSchema,
+    union?: Map<string, number | null>,
+  ): Map<string, number | null> => {
+    const map: Map<ProtobufAtomic, number | null> = union ?? new Map();
+
+    // CONSTANTS
+    for (const c of meta.constants)
+      if (c.type === "boolean")
+        map.set("bool", getSequence(c.values[0]?.tags[0] ?? []));
+      else if (c.type === "bigint") {
+        const init: ProtobufAtomic.BigNumeric = deduce_bigint_type(
+          c.values.map((v) => BigInt(v.value)),
+        );
+        for (const value of c.values)
+          decode_bigint({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      } else if (c.type === "number") {
+        const init: ProtobufAtomic.Numeric = deduce_numeric_type(
+          c.values.map((v) => v.value) as number[],
+        );
+        for (const value of c.values)
+          decode_number({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      } else if (c.type === "string")
+        map.set("string", getSequence(c.values[0]?.tags[0] ?? []));
+    if (meta.templates.length)
+      map.set("string", getSequence(meta.templates[0]?.tags[0] ?? []));
+
+    // ATOMICS
+    for (const atomic of meta.atomics)
+      if (atomic.type === "boolean")
+        map.set("bool", getSequence(atomic.tags[0] ?? []));
+      else if (atomic.type === "bigint")
+        decode_bigint({
+          map,
+          tags: atomic.tags,
+          default: "int64",
+        });
+      else if (atomic.type === "number")
+        decode_number({
+          map,
+          tags: atomic.tags,
+          default: "double",
+        });
+      else if (atomic.type === "string")
+        map.set("string", getSequence(atomic.tags[0] ?? []));
+
+    // SORTING IF REQUIRED
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
+  };
+
+  export const getNumbers = (
+    meta: MetadataSchema,
+    union?: Map<string, number | null>,
+  ): Map<string, number | null> => {
+    const map: Map<ProtobufAtomic.Numeric, number | null> = union ?? new Map();
+    for (const c of meta.constants)
+      if (c.type === "number") {
+        const init: ProtobufAtomic.Numeric = deduce_numeric_type(
+          c.values.map((v) => v.value) as number[],
+        );
+        for (const value of c.values)
+          decode_number({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      }
+    for (const atomic of meta.atomics)
+      if (atomic.type === "number")
+        decode_number({
+          map,
+          tags: atomic.tags,
+          default: "double",
+        });
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
+  };
+
+  export const getBigints = (
+    meta: MetadataSchema,
+    union?: Map<string, number | null>,
+  ): Map<string, number | null> => {
+    const map: Map<ProtobufAtomic.BigNumeric, number | null> =
+      union ?? new Map();
+    for (const c of meta.constants)
+      if (c.type === "bigint") {
+        const init: ProtobufAtomic.BigNumeric = deduce_bigint_type(
+          c.values.map((v) => BigInt(v.value)),
+        );
+        for (const value of c.values)
+          decode_bigint({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      }
+    for (const atomic of meta.atomics)
+      if (atomic.type === "bigint")
+        decode_bigint({
+          map,
+          tags: atomic.tags,
+          default: "int64",
+        });
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
+  };
+
+  const arrange = (map: Map<ProtobufAtomic, number | null>): void => {
+    const entries = Array.from(map.entries()).sort((a, b) =>
+      compare(a[0], b[0]),
+    );
+    map.clear();
+    for (const [key, value] of entries) map.set(key, value);
+  };
+
+  export const compare = (x: ProtobufAtomic, y: ProtobufAtomic): number =>
+    ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!;
+}
+
+const ATOMIC_ORDER = new Map<ProtobufAtomic, number>(
+  (
+    [
+      "bool",
+      "int32",
+      "uint32",
+      "int64",
+      "uint64",
+      "float",
+      "double",
+      "string",
+    ] as const
+  ).map((str, i) => [str, i]),
+);
+
+const deduce_bigint_type = (values: bigint[]): ProtobufAtomic.BigNumeric =>
+  values.some((v) => v < 0) ? "int64" : "uint64";
+const deduce_numeric_type = (values: number[]): ProtobufAtomic.Numeric =>
+  values.every((v) => Math.floor(v) === v)
+    ? values.every((v) => -2147483648 <= v && v <= 2147483647)
+      ? "int32"
+      : "int64"
+    : "double";
+
+const decode_bigint = (next: {
+  map: Map<ProtobufAtomic, number | null>;
+  tags: IMetadataTypeTag[][];
+  default: ProtobufAtomic.BigNumeric;
+}): void => {
+  if (next.tags.length === 0) {
+    next.map.set(next.default, null);
+    return;
+  }
+  for (const row of next.tags) {
+    const value: ProtobufAtomic.BigNumeric | undefined = row.find(
+      (tag) =>
+        tag.kind === "type" &&
+        (tag.value === "int64" || tag.value === "uint64"),
+    )?.value;
+    next.map.set(value ?? "int64", ProtobufUtil.getSequence(row));
+  }
+};
+
+const decode_number = (next: {
+  map: Map<ProtobufAtomic, number | null>;
+  tags: IMetadataTypeTag[][];
+  default: ProtobufAtomic.Numeric;
+}): void => {
+  if (next.tags.length === 0) {
+    next.map.set(next.default, null);
+    return;
+  }
+  for (const row of next.tags) {
+    const value: ProtobufAtomic.Numeric | undefined = row.find(
+      (tag) =>
+        tag.kind === "type" &&
+        (tag.value === "int32" ||
+          tag.value === "uint32" ||
+          tag.value === "int64" ||
+          tag.value === "uint64" ||
+          tag.value === "float" ||
+          tag.value === "double"),
+    )?.value;
+    next.map.set(value ?? "double", ProtobufUtil.getSequence(row));
+  }
+};

package/src/programmers/helpers/ProtobufWire.ts

@@ -0,0 +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,
+}

package/src/programmers/helpers/PruneJoiner.ts

@@ -0,0 +1,146 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { metadata_to_pattern } from "../iterate/metadata_to_pattern";
+import { prune_object_properties } from "../iterate/prune_object_properties";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace PruneJoiner {
+  export const object = (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry[];
+    object: MetadataObjectType;
+  }): ts.ConciseBody => {
+    // PREPARE ASSETS
+    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+
+    const statements: ts.Statement[] = regular
+      .map((entry) =>
+        ts.isBlock(entry.expression)
+          ? [...entry.expression.statements]
+          : [ts.factory.createExpressionStatement(entry.expression)],
+      )
+      .flat();
+    if (dynamic.length)
+      statements.push(
+        ts.factory.createExpressionStatement(
+          iterate_dynamic_properties({
+            regular,
+            dynamic,
+            input: props.input,
+          }),
+        ),
+      );
+
+    statements.push(prune_object_properties(props.object));
+    return ts.factory.createBlock(statements, true);
+  };
+
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.ArrowFunction;
+  }) =>
+    ts.factory.createCallExpression(
+      IdentifierFactory.access(props.input, "forEach"),
+      undefined,
+      [props.arrow],
+    );
+
+  export const tuple = (props: {
+    elements: ts.ConciseBody[];
+    rest: ts.ConciseBody | null;
+  }): ts.Block => {
+    const entire: ts.ConciseBody[] = [...props.elements];
+    if (props.rest !== null) entire.push(props.rest);
+
+    const statements: ts.Statement[] = entire
+      .map((elem) =>
+        ts.isBlock(elem)
+          ? [...elem.statements]
+          : [ts.factory.createExpressionStatement(elem)],
+      )
+      .flat();
+    return ts.factory.createBlock(statements, true);
+  };
+}
+
+const iterate_dynamic_properties = (props: {
+  regular: IExpressionEntry[];
+  dynamic: IExpressionEntry[];
+  input: ts.Expression;
+}) =>
+  ts.factory.createCallExpression(
+    IdentifierFactory.access(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier("Object.entries"),
+        undefined,
+        [props.input],
+      ),
+      "forEach",
+    ),
+    undefined,
+    [
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            ts.factory.createArrayBindingPattern(
+              ["key", "value"].map((l) =>
+                ts.factory.createBindingElement(
+                  undefined,
+                  undefined,
+                  ts.factory.createIdentifier(l),
+                  undefined,
+                ),
+              ),
+            ),
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ts.factory.createIfStatement(
+              ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                ts.factory.createIdentifier("value"),
+              ),
+              ts.factory.createReturnStatement(),
+            ),
+            ...props.regular.map(({ key }) =>
+              ts.factory.createIfStatement(
+                ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral(key.getSoleLiteral()!),
+                  ts.factory.createIdentifier("key"),
+                ),
+                ts.factory.createReturnStatement(),
+              ),
+            ),
+            ...props.dynamic.map((dynamic) =>
+              ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern({
+                      top: true,
+                      metadata: dynamic.key,
+                    })}/).test`,
+                  ),
+                  undefined,
+                  [ts.factory.createIdentifier("key")],
+                ),
+                ts.isBlock(dynamic.expression)
+                  ? dynamic.expression
+                  : ts.factory.createBlock([
+                      ts.factory.createExpressionStatement(dynamic.expression),
+                    ]),
+              ),
+            ),
+          ],
+          true,
+        ),
+      ),
+    ],
+  );