typia 5.3.0-dev.20231112 → 5.3.0-dev.20231119

package/src/programmers/helpers/NotationJoiner.ts

@@ -1,146 +1,132 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace NotationJoiner {
-    export const object =
-        (rename: (str: string) => string) =>
-        (
-            input: ts.Expression,
-            entries: IExpressionEntry<ts.Expression>[],
-        ): ts.ConciseBody => {
-            if (entries.length === 0) return ts.factory.createIdentifier("{}");
-
-            const regular = entries.filter((e) => e.key.isSoleLiteral());
-            const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
-            const literal = ts.factory.createObjectLiteralExpression(
-                regular.map((entry) => {
-                    const str: string = rename(entry.key.getSoleLiteral()!);
-                    return ts.factory.createPropertyAssignment(
-                        Escaper.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(true)(
-                                    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(
-                    "output",
-                    ts.factory.createAsExpression(
-                        literal,
-                        TypeFactory.keyword("any"),
-                    ),
-                ),
-                ts.factory.createForOfStatement(
-                    undefined,
-                    StatementFactory.entry("key")("value"),
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Object.entries"),
-                        undefined,
-                        [input],
-                    ),
-                    ts.factory.createBlock(statements),
-                ),
-                ts.factory.createReturnStatement(output),
-            ]);
-        };
-
-    export const tuple = (
-        children: ts.Expression[],
-        rest: ts.Expression | null,
-    ): ts.Expression => {
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                rest === null
-                    ? children
-                    : [...children, ts.factory.createSpreadElement(rest)],
-                true,
-            ),
-            TypeFactory.keyword("any"),
-        );
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.Expression) =>
-        ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(input, "map"),
-            undefined,
-            [arrow],
-        );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace NotationJoiner {
+  export const object =
+    (rename: (str: string) => string) =>
+    (
+      input: ts.Expression,
+      entries: IExpressionEntry<ts.Expression>[],
+    ): ts.ConciseBody => {
+      if (entries.length === 0) return ts.factory.createIdentifier("{}");
+
+      const regular = entries.filter((e) => e.key.isSoleLiteral());
+      const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+      const literal = ts.factory.createObjectLiteralExpression(
+        regular.map((entry) => {
+          const str: string = rename(entry.key.getSoleLiteral()!);
+          return ts.factory.createPropertyAssignment(
+            Escaper.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(true)(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(
+          "output",
+          ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
+        ),
+        ts.factory.createForOfStatement(
+          undefined,
+          StatementFactory.entry("key")("value"),
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Object.entries"),
+            undefined,
+            [input],
+          ),
+          ts.factory.createBlock(statements),
+        ),
+        ts.factory.createReturnStatement(output),
+      ]);
+    };
+
+  export const tuple = (
+    children: ts.Expression[],
+    rest: ts.Expression | null,
+  ): ts.Expression => {
+    return ts.factory.createAsExpression(
+      ts.factory.createArrayLiteralExpression(
+        rest === null
+          ? children
+          : [...children, ts.factory.createSpreadElement(rest)],
+        true,
+      ),
+      TypeFactory.keyword("any"),
+    );
+  };
+
+  export const array = (input: ts.Expression, arrow: ts.Expression) =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(input, "map"),
+      undefined,
+      [arrow],
+    );
+}

package/src/programmers/helpers/OptionPredicator.ts

@@ -1,15 +1,15 @@
-import { ITransformOptions } from "../../transformers/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;
-}
+import { ITransformOptions } from "../../transformers/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

@@ -1,126 +1,125 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
-
-export namespace ProtobufUtil {
-    export const isStaticObject = (obj: MetadataObject): boolean =>
-        obj.properties.length >= 1 &&
-        obj.properties.every((p) => p.key.isSoleLiteral());
-
-    export const size = (meta: Metadata): number =>
-        getAtomics(meta).length +
-        meta.arrays.length +
-        meta.tuples.length +
-        meta.natives.length +
-        meta.objects.length +
-        meta.maps.length;
-
-    export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
-
-    export const getAtomics = (meta: Metadata): ProtobufAtomic[] => {
-        const set: Set<ProtobufAtomic> = new Set();
-        if (meta.templates.length) set.add("string");
-        for (const c of meta.constants)
-            if (c.type === "boolean") set.add("bool");
-            else if (c.type === "bigint") set.add("uint64");
-            else if (c.type === "number")
-                set.add(deduce_numeric_type(c.values as number[]));
-            else if (c.type === "string") set.add("string");
-        for (const atomic of meta.atomics)
-            if (atomic.type === "boolean") set.add("bool");
-            else if (atomic.type === "bigint")
-                decode_bigint(atomic.tags).forEach((t) => set.add(t));
-            else if (atomic.type === "number")
-                decode_number(atomic.tags).forEach((t) => set.add(t));
-            else if (atomic.type === "string") set.add("string");
-
-        return [...set].sort(compare);
-    };
-
-    export const getNumbers = (meta: Metadata) => {
-        const set: Set<ProtobufAtomic.Numeric> = new Set();
-        for (const c of meta.constants)
-            if (c.type === "number")
-                set.add(deduce_numeric_type(c.values as number[]));
-        for (const atomic of meta.atomics)
-            if (atomic.type === "number")
-                decode_number(atomic.tags).forEach((t) => set.add(t));
-        return [...set].sort(compare);
-    };
-
-    export const getBigints = (meta: Metadata) => {
-        const set: Set<ProtobufAtomic.BigNumeric> = new Set();
-        for (const c of meta.constants)
-            if (c.type === "bigint") set.add("uint64");
-        for (const atomic of meta.atomics)
-            if (atomic.type === "bigint")
-                decode_bigint(atomic.tags).forEach((t) => set.add(t));
-        return [...set].sort(compare);
-    };
-
-    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_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 = (
-    typeTags: IMetadataTypeTag[][],
-): ProtobufAtomic.BigNumeric[] => {
-    if (typeTags.length === 0) return ["int64"];
-
-    const types: Set<ProtobufAtomic.BigNumeric> = new Set();
-    for (const row of typeTags) {
-        const value: ProtobufAtomic.BigNumeric | undefined = row.find(
-            (tag) =>
-                tag.kind === "type" &&
-                (tag.value === "int64" || tag.value === "uint64"),
-        )?.value;
-        types.add(value ?? "int64");
-    }
-    return [...types];
-};
-
-const decode_number = (
-    typeTags: IMetadataTypeTag[][],
-): ProtobufAtomic.Numeric[] => {
-    if (typeTags.length === 0) return ["double"];
-
-    const types: Set<ProtobufAtomic.Numeric> = new Set();
-    for (const row of typeTags) {
-        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;
-        types.add(value ?? "double");
-    }
-    return [...types];
-};
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
+
+export namespace ProtobufUtil {
+  export const isStaticObject = (obj: MetadataObject): boolean =>
+    obj.properties.length >= 1 &&
+    obj.properties.every((p) => p.key.isSoleLiteral());
+
+  export const size = (meta: Metadata): number =>
+    getAtomics(meta).length +
+    meta.arrays.length +
+    meta.tuples.length +
+    meta.natives.length +
+    meta.objects.length +
+    meta.maps.length;
+
+  export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
+
+  export const getAtomics = (meta: Metadata): ProtobufAtomic[] => {
+    const set: Set<ProtobufAtomic> = new Set();
+    if (meta.templates.length) set.add("string");
+    for (const c of meta.constants)
+      if (c.type === "boolean") set.add("bool");
+      else if (c.type === "bigint") set.add("uint64");
+      else if (c.type === "number")
+        set.add(deduce_numeric_type(c.values as number[]));
+      else if (c.type === "string") set.add("string");
+    for (const atomic of meta.atomics)
+      if (atomic.type === "boolean") set.add("bool");
+      else if (atomic.type === "bigint")
+        decode_bigint(atomic.tags).forEach((t) => set.add(t));
+      else if (atomic.type === "number")
+        decode_number(atomic.tags).forEach((t) => set.add(t));
+      else if (atomic.type === "string") set.add("string");
+
+    return [...set].sort(compare);
+  };
+
+  export const getNumbers = (meta: Metadata) => {
+    const set: Set<ProtobufAtomic.Numeric> = new Set();
+    for (const c of meta.constants)
+      if (c.type === "number")
+        set.add(deduce_numeric_type(c.values as number[]));
+    for (const atomic of meta.atomics)
+      if (atomic.type === "number")
+        decode_number(atomic.tags).forEach((t) => set.add(t));
+    return [...set].sort(compare);
+  };
+
+  export const getBigints = (meta: Metadata) => {
+    const set: Set<ProtobufAtomic.BigNumeric> = new Set();
+    for (const c of meta.constants) if (c.type === "bigint") set.add("uint64");
+    for (const atomic of meta.atomics)
+      if (atomic.type === "bigint")
+        decode_bigint(atomic.tags).forEach((t) => set.add(t));
+    return [...set].sort(compare);
+  };
+
+  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_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 = (
+  typeTags: IMetadataTypeTag[][],
+): ProtobufAtomic.BigNumeric[] => {
+  if (typeTags.length === 0) return ["int64"];
+
+  const types: Set<ProtobufAtomic.BigNumeric> = new Set();
+  for (const row of typeTags) {
+    const value: ProtobufAtomic.BigNumeric | undefined = row.find(
+      (tag) =>
+        tag.kind === "type" &&
+        (tag.value === "int64" || tag.value === "uint64"),
+    )?.value;
+    types.add(value ?? "int64");
+  }
+  return [...types];
+};
+
+const decode_number = (
+  typeTags: IMetadataTypeTag[][],
+): ProtobufAtomic.Numeric[] => {
+  if (typeTags.length === 0) return ["double"];
+
+  const types: Set<ProtobufAtomic.Numeric> = new Set();
+  for (const row of typeTags) {
+    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;
+    types.add(value ?? "double");
+  }
+  return [...types];
+};

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