typia 5.3.12-dev.20240121 → 5.3.12-dev.20240122

package/src/programmers/helpers/NotationJoiner.ts

@@ -1,132 +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,125 +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,
+}