typia 5.0.0-dev.20230711 → 5.0.0-dev.20230713

package/src/factories/internal/protocols/iterate_protocol_object.ts

@@ -1,110 +1,110 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { Atomic } from "../../../typings/Atomic";
-
-import { MapUtil } from "../../../utils/MapUtil";
-
-import { IProtocolMap } from "../../../messages/IProtocolMap";
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const iterate_protocol_object =
-    (sole: boolean) =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (obj: MetadataObject): string | IProtocolMap => {
-        // ONLY REGULAR PROPERTIES
-        const statics: MetadataProperty[] = obj.properties.filter(filter(true));
-        const dynamics: Metadata.Entry[] = aggregate(
-            obj.properties.filter(filter(false)),
-        );
-        if (dynamics.length === 0) return obj.name;
-
-        const regular: MetadataObject | undefined = statics.length
-            ? (() => {
-                  const r: MetadataObject = ProtocolMetadataUtil.object(
-                      `${obj.name}.__Regular`,
-                      dict.size,
-                  );
-                  r.properties.push(...statics);
-                  emplace_protocol_object(dict)(r);
-                  return r;
-              })()
-            : undefined;
-
-        // ONLY ONE TYPED DYNAMIC PROPERTY EXISTS
-        if (regular === undefined && dynamics.length === 1 && sole === true) {
-            const { key, value } = dynamics[0]!;
-            return {
-                type: "map",
-                key: key.getName(),
-                value: ProtocolMetadataUtil.standalone(value)
-                    ? iterate_protocol_metadata(dict)(value)([]).oneOf[0]!.type
-                    : (() => {
-                          const wrapper = ProtocolMetadataUtil.object(
-                              `${obj.name}.__Wrapper`,
-                              dict.size,
-                          );
-                          wrapper.properties.push(
-                              ProtocolMetadataUtil.property("value", value, []),
-                          );
-                          emplace_protocol_object(dict)(wrapper);
-                          return wrapper.name;
-                      })(),
-            };
-        }
-
-        // DO WRAP
-        const wrapper: MetadataObject = ProtocolMetadataUtil.object(
-            `${obj.name}.__Wrapper`,
-            dict.size,
-        );
-        if (regular !== undefined)
-            wrapper.properties.push(
-                ProtocolMetadataUtil.property(
-                    "regular",
-                    ProtocolMetadataUtil.reference(regular),
-                    [],
-                ),
-            );
-        wrapper.properties.push(
-            ...dynamics.map((map, i) =>
-                ProtocolMetadataUtil.property(
-                    `__map_${i}`,
-                    ProtocolMetadataUtil.map(map),
-                    [],
-                ),
-            ),
-        );
-        emplace_protocol_object(dict)(wrapper);
-        return wrapper.name;
-    };
-
-const filter = (regular: boolean) => (prop: MetadataProperty) =>
-    regular === prop.key.isSoleLiteral();
-
-const aggregate = (properties: MetadataProperty[]): Metadata.Entry[] => {
-    const unique: Map<Atomic.Literal, MetadataProperty[]> = new Map();
-    for (const prop of properties) {
-        if (prop.key.templates)
-            MapUtil.take(unique)("string", () => []).push(prop);
-        for (const type of prop.key.atomics)
-            MapUtil.take(unique)(type, () => []).push(prop);
-        for (const { type } of prop.key.constants)
-            MapUtil.take(unique)(type, () => []).push(prop);
-    }
-    const output: Metadata.Entry[] = [];
-    for (const [key, properties] of unique) {
-        const value: Metadata = properties
-            .map((x) => x.value)
-            .reduce((x, y) => Metadata.merge(x, y));
-        output.push({
-            key: ProtocolMetadataUtil.atomic(key),
-            value,
-        });
-    }
-    return output;
-};
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { Atomic } from "../../../typings/Atomic";
+
+import { MapUtil } from "../../../utils/MapUtil";
+
+import { IProtocolMap } from "../../../messages/IProtocolMap";
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
+
+export const iterate_protocol_object =
+    (sole: boolean) =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (obj: MetadataObject): string | IProtocolMap => {
+        // ONLY REGULAR PROPERTIES
+        const statics: MetadataProperty[] = obj.properties.filter(filter(true));
+        const dynamics: Metadata.Entry[] = aggregate(
+            obj.properties.filter(filter(false)),
+        );
+        if (dynamics.length === 0) return obj.name;
+
+        const regular: MetadataObject | undefined = statics.length
+            ? (() => {
+                  const r: MetadataObject = ProtocolMetadataUtil.object(
+                      `${obj.name}.__Regular`,
+                      dict.size,
+                  );
+                  r.properties.push(...statics);
+                  emplace_protocol_object(dict)(r);
+                  return r;
+              })()
+            : undefined;
+
+        // ONLY ONE TYPED DYNAMIC PROPERTY EXISTS
+        if (regular === undefined && dynamics.length === 1 && sole === true) {
+            const { key, value } = dynamics[0]!;
+            return {
+                type: "map",
+                key: key.getName(),
+                value: ProtocolMetadataUtil.standalone(value)
+                    ? iterate_protocol_metadata(dict)(value)([]).oneOf[0]!.type
+                    : (() => {
+                          const wrapper = ProtocolMetadataUtil.object(
+                              `${obj.name}.__Wrapper`,
+                              dict.size,
+                          );
+                          wrapper.properties.push(
+                              ProtocolMetadataUtil.property("value", value, []),
+                          );
+                          emplace_protocol_object(dict)(wrapper);
+                          return wrapper.name;
+                      })(),
+            };
+        }
+
+        // DO WRAP
+        const wrapper: MetadataObject = ProtocolMetadataUtil.object(
+            `${obj.name}.__Wrapper`,
+            dict.size,
+        );
+        if (regular !== undefined)
+            wrapper.properties.push(
+                ProtocolMetadataUtil.property(
+                    "regular",
+                    ProtocolMetadataUtil.reference(regular),
+                    [],
+                ),
+            );
+        wrapper.properties.push(
+            ...dynamics.map((map, i) =>
+                ProtocolMetadataUtil.property(
+                    `__map_${i}`,
+                    ProtocolMetadataUtil.map(map),
+                    [],
+                ),
+            ),
+        );
+        emplace_protocol_object(dict)(wrapper);
+        return wrapper.name;
+    };
+
+const filter = (regular: boolean) => (prop: MetadataProperty) =>
+    regular === prop.key.isSoleLiteral();
+
+const aggregate = (properties: MetadataProperty[]): Metadata.Entry[] => {
+    const unique: Map<Atomic.Literal, MetadataProperty[]> = new Map();
+    for (const prop of properties) {
+        if (prop.key.templates)
+            MapUtil.take(unique)("string", () => []).push(prop);
+        for (const type of prop.key.atomics)
+            MapUtil.take(unique)(type, () => []).push(prop);
+        for (const { type } of prop.key.constants)
+            MapUtil.take(unique)(type, () => []).push(prop);
+    }
+    const output: Metadata.Entry[] = [];
+    for (const [key, properties] of unique) {
+        const value: Metadata = properties
+            .map((x) => x.value)
+            .reduce((x, y) => Metadata.merge(x, y));
+        output.push({
+            key: ProtocolMetadataUtil.atomic(key),
+            value,
+        });
+    }
+    return output;
+};

package/src/factories/internal/protocols/iterate_protocol_repeated.ts

@@ -1,34 +1,34 @@
-import { IMetadataTag } from "../../../metadata/IMetadataTag";
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProtocolMap } from "../../../messages/IProtocolMap";
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const iterate_protocol_repeated =
-    (container: "Array" | "Set") =>
-    (sole: boolean, bucket: boolean) =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata) =>
-    (tags: IMetadataTag[]): string | IProtocolMap => {
-        sole &&= ProtocolMetadataUtil.standalone(meta);
-        if (sole === true)
-            return iterate_protocol_metadata(dict)(meta)(tags).oneOf[0]!.type;
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `${container}.${bucket ? "Element" : "Wrapper"}<${meta.getName()}>`,
-            dict.size,
-        );
-        obj.properties.push(
-            ProtocolMetadataUtil.property(
-                "value",
-                bucket ? meta : ProtocolMetadataUtil.array(meta),
-                tags,
-            ),
-        );
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMap } from "../../../messages/IProtocolMap";
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
+
+export const iterate_protocol_repeated =
+    (container: "Array" | "Set") =>
+    (sole: boolean, bucket: boolean) =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata) =>
+    (tags: IMetadataTag[]): string | IProtocolMap => {
+        sole &&= ProtocolMetadataUtil.standalone(meta);
+        if (sole === true)
+            return iterate_protocol_metadata(dict)(meta)(tags).oneOf[0]!.type;
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            `${container}.${bucket ? "Element" : "Wrapper"}<${meta.getName()}>`,
+            dict.size,
+        );
+        obj.properties.push(
+            ProtocolMetadataUtil.property(
+                "value",
+                bucket ? meta : ProtocolMetadataUtil.array(meta),
+                tags,
+            ),
+        );
+        emplace_protocol_object(dict)(obj);
+        return obj.name;
+    };

package/src/factories/internal/protocols/iterate_protocol_tuple.ts

@@ -1,29 +1,29 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-
-export const iterate_protocol_tuple =
-    (dict: Map<string, IProtocolMessage>) =>
-    (tuple: Metadata[]): string => {
-        const name: string = `[${tuple.map((m) => m.getName()).join(", ")}]`;
-        if (dict.has(name)) return name;
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            name,
-            dict.size,
-        );
-        obj.properties.push(
-            ...tuple.map((value, i) =>
-                ProtocolMetadataUtil.property(
-                    `v${i}`,
-                    value.rest ? ProtocolMetadataUtil.array(value.rest) : value,
-                    [],
-                ),
-            ),
-        );
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_tuple =
+    (dict: Map<string, IProtocolMessage>) =>
+    (tuple: Metadata[]): string => {
+        const name: string = `[${tuple.map((m) => m.getName()).join(", ")}]`;
+        if (dict.has(name)) return name;
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            name,
+            dict.size,
+        );
+        obj.properties.push(
+            ...tuple.map((value, i) =>
+                ProtocolMetadataUtil.property(
+                    `v${i}`,
+                    value.rest ? ProtocolMetadataUtil.array(value.rest) : value,
+                    [],
+                ),
+            ),
+        );
+        emplace_protocol_object(dict)(obj);
+        return obj.name;
+    };

package/src/functional/$number.ts

@@ -3,10 +3,11 @@ import { TypeGuardError } from "../TypeGuardError";
 export const $number = (value: number): number => {
     if (isFinite(value) === false)
         throw new TypeGuardError({
-            method: "typia.stringify",
+            method: "typia.json.stringify",
             expected: "number",
             value,
-            message: "Error on typia.stringify(): infinite or not a number.",
+            message:
+                "Error on typia.json.stringify(): infinite or not a number.",
         });
     return value;
 };

package/src/functional/$proto_bytes.ts

@@ -1,25 +1,25 @@
-import { $varint_decode_i32, $varint_encode } from "./$varint";
-
-export function $proto_bytes_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: Uint8Array,
-): number {
-    offset = $varint_encode(dst, offset, value.length);
-    dst.set(value, offset);
-    offset += value.length;
-    return offset;
-}
-
-export function $proto_bytes_decode(
-    src: Uint8Array,
-    offset: number,
-): [value: Uint8Array, offset: number] {
-    let length = 0;
-
-    [length, offset] = $varint_decode_i32(src, offset); // Max Length: ~2GB
-    const value = src.subarray(offset, offset + length);
-    offset += length;
-
-    return [value, offset];
-}
+import { $varint_decode_i32, $varint_encode } from "./$varint";
+
+export function $proto_bytes_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: Uint8Array,
+): number {
+    offset = $varint_encode(dst, offset, value.length);
+    dst.set(value, offset);
+    offset += value.length;
+    return offset;
+}
+
+export function $proto_bytes_decode(
+    src: Uint8Array,
+    offset: number,
+): [value: Uint8Array, offset: number] {
+    let length = 0;
+
+    [length, offset] = $varint_decode_i32(src, offset); // Max Length: ~2GB
+    const value = src.subarray(offset, offset + length);
+    offset += length;
+
+    return [value, offset];
+}

package/src/functional/$proto_field.ts

@@ -1,30 +1,30 @@
-import { $varint_decode_i32, $varint_encode } from "./$varint";
-
-export enum $proto_field_wiretype {
-    VARINT = 0,
-    I64 = 1,
-    LEN = 2,
-    SGROUP = 3, // deprecated
-    EGROUP = 4, // deprecated
-    I32 = 5,
-}
-
-export function $proto_field_encode(
-    dst: Uint8Array,
-    offset: number,
-    fieldNumber: number,
-    wireType: $proto_field_wiretype,
-): number {
-    const tag = (fieldNumber << 3) | Number(wireType);
-    return $varint_encode(dst, offset, tag);
-}
-
-export function $proto_field_decode(
-    buf: Uint8Array,
-    offset: number,
-): [fieldNumber: number, wireType: $proto_field_wiretype, offset: number] {
-    const [tag, o] = $varint_decode_i32(buf, offset);
-    const fieldNumber = tag >>> 3;
-    const wireType = tag & 0b111;
-    return [fieldNumber, wireType, o];
-}
+import { $varint_decode_i32, $varint_encode } from "./$varint";
+
+export enum $proto_field_wiretype {
+    VARINT = 0,
+    I64 = 1,
+    LEN = 2,
+    SGROUP = 3, // deprecated
+    EGROUP = 4, // deprecated
+    I32 = 5,
+}
+
+export function $proto_field_encode(
+    dst: Uint8Array,
+    offset: number,
+    fieldNumber: number,
+    wireType: $proto_field_wiretype,
+): number {
+    const tag = (fieldNumber << 3) | Number(wireType);
+    return $varint_encode(dst, offset, tag);
+}
+
+export function $proto_field_decode(
+    buf: Uint8Array,
+    offset: number,
+): [fieldNumber: number, wireType: $proto_field_wiretype, offset: number] {
+    const [tag, o] = $varint_decode_i32(buf, offset);
+    const fieldNumber = tag >>> 3;
+    const wireType = tag & 0b111;
+    return [fieldNumber, wireType, o];
+}

package/src/functional/$proto_float.ts

@@ -1,37 +1,37 @@
-export function $proto_float32_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: number,
-): number {
-    new DataView(dst.buffer).setFloat32(offset, value, true);
-    offset += 4;
-    return offset;
-}
-
-export function $proto_float32_decode(
-    src: Uint8Array,
-    offset: number,
-): [value: number, offset: number] {
-    const value = new DataView(src.buffer).getFloat32(offset, true);
-    offset += 4;
-    return [value, offset];
-}
-
-export function $proto_float64_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: number,
-): number {
-    new DataView(dst.buffer).setFloat64(offset, value, true);
-    offset += 8;
-    return offset;
-}
-
-export function $proto_float64_decode(
-    src: Uint8Array,
-    offset: number,
-): [value: number, offset: number] {
-    const value = new DataView(src.buffer).getFloat64(offset, true);
-    offset += 8;
-    return [value, offset];
-}
+export function $proto_float32_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number {
+    new DataView(dst.buffer).setFloat32(offset, value, true);
+    offset += 4;
+    return offset;
+}
+
+export function $proto_float32_decode(
+    src: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const value = new DataView(src.buffer).getFloat32(offset, true);
+    offset += 4;
+    return [value, offset];
+}
+
+export function $proto_float64_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number {
+    new DataView(dst.buffer).setFloat64(offset, value, true);
+    offset += 8;
+    return offset;
+}
+
+export function $proto_float64_decode(
+    src: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const value = new DataView(src.buffer).getFloat64(offset, true);
+    offset += 8;
+    return [value, offset];
+}

package/src/functional/$proto_i32.ts

@@ -1,29 +1,29 @@
-export function $proto_i32_encode(
-    dst: Uint8Array,
-    offset: number,
-    value: number,
-): number {
-    value = (value | 0) >>> 0;
-
-    dst[offset] = value & 0xff;
-    dst[offset + 1] = (value >>> 8) & 0xff;
-    dst[offset + 2] = (value >>> 16) & 0xff;
-    dst[offset + 3] = (value >>> 24) & 0xff;
-    offset += 4;
-
-    return offset;
-}
-
-export function $proto_i32_decode(
-    buf: Uint8Array,
-    offset: number,
-): [value: number, offset: number] {
-    const value =
-        (buf[offset]! << 0) |
-        (buf[offset + 1]! << 8) |
-        (buf[offset + 2]! << 16) |
-        (buf[offset + 3]! << 24);
-    offset += 4;
-
-    return [value, offset];
-}
+export function $proto_i32_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number {
+    value = (value | 0) >>> 0;
+
+    dst[offset] = value & 0xff;
+    dst[offset + 1] = (value >>> 8) & 0xff;
+    dst[offset + 2] = (value >>> 16) & 0xff;
+    dst[offset + 3] = (value >>> 24) & 0xff;
+    offset += 4;
+
+    return offset;
+}
+
+export function $proto_i32_decode(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const value =
+        (buf[offset]! << 0) |
+        (buf[offset + 1]! << 8) |
+        (buf[offset + 2]! << 16) |
+        (buf[offset + 3]! << 24);
+    offset += 4;
+
+    return [value, offset];
+}