typia 5.0.4 → 5.0.5-dev.20230921

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

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,143 +1,143 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { prune_object_properties } from "../internal/prune_object_properties";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace PruneJoiner {
-    export const object = (
-        input: ts.Expression,
-        entries: IExpressionEntry[],
-        obj: MetadataObject,
-    ): ts.ConciseBody => {
-        // PREPARE ASSETS
-        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
-
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            regular.map((entry) =>
-                ts.isBlock(entry.expression)
-                    ? [...entry.expression.statements]
-                    : [ts.factory.createExpressionStatement(entry.expression)],
-            ),
-        );
-        if (dynamic.length)
-            statements.push(
-                ts.factory.createExpressionStatement(
-                    iterate_dynamic_properties({ regular, dynamic })(input),
-                ),
-            );
-
-        statements.push(prune_object_properties(obj));
-        return ts.factory.createBlock(statements, true);
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("forEach"),
-            undefined,
-            [arrow],
-        );
-
-    export const tuple = (
-        children: ts.ConciseBody[],
-        rest: ts.ConciseBody | null,
-    ): ts.Block => {
-        const entire: ts.ConciseBody[] = [...children];
-        if (rest !== null) entire.push(rest);
-
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            entire.map((elem) =>
-                ts.isBlock(elem)
-                    ? [...elem.statements]
-                    : [ts.factory.createExpressionStatement(elem)],
-            ),
-        );
-        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,
-                    [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(
-                                                true,
-                                            )(dynamic.key)}/).test`,
-                                        ),
-                                        undefined,
-                                        [ts.factory.createIdentifier("key")],
-                                    ),
-                                    ts.isBlock(dynamic.expression)
-                                        ? dynamic.expression
-                                        : ts.factory.createBlock([
-                                              ts.factory.createExpressionStatement(
-                                                  dynamic.expression,
-                                              ),
-                                          ]),
-                                ),
-                            ),
-                        ],
-                        true,
-                    ),
-                ),
-            ],
-        );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { prune_object_properties } from "../internal/prune_object_properties";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace PruneJoiner {
+    export const object = (
+        input: ts.Expression,
+        entries: IExpressionEntry[],
+        obj: MetadataObject,
+    ): ts.ConciseBody => {
+        // PREPARE ASSETS
+        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            regular.map((entry) =>
+                ts.isBlock(entry.expression)
+                    ? [...entry.expression.statements]
+                    : [ts.factory.createExpressionStatement(entry.expression)],
+            ),
+        );
+        if (dynamic.length)
+            statements.push(
+                ts.factory.createExpressionStatement(
+                    iterate_dynamic_properties({ regular, dynamic })(input),
+                ),
+            );
+
+        statements.push(prune_object_properties(obj));
+        return ts.factory.createBlock(statements, true);
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.access(input)("forEach"),
+            undefined,
+            [arrow],
+        );
+
+    export const tuple = (
+        children: ts.ConciseBody[],
+        rest: ts.ConciseBody | null,
+    ): ts.Block => {
+        const entire: ts.ConciseBody[] = [...children];
+        if (rest !== null) entire.push(rest);
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            entire.map((elem) =>
+                ts.isBlock(elem)
+                    ? [...elem.statements]
+                    : [ts.factory.createExpressionStatement(elem)],
+            ),
+        );
+        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,
+                    [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(
+                                                true,
+                                            )(dynamic.key)}/).test`,
+                                        ),
+                                        undefined,
+                                        [ts.factory.createIdentifier("key")],
+                                    ),
+                                    ts.isBlock(dynamic.expression)
+                                        ? dynamic.expression
+                                        : ts.factory.createBlock([
+                                              ts.factory.createExpressionStatement(
+                                                  dynamic.expression,
+                                              ),
+                                          ]),
+                                ),
+                            ),
+                        ],
+                        true,
+                    ),
+                ),
+            ],
+        );