typia 4.1.6 → 5.0.0-dev.20230713

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

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

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

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

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

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

package/src/functional/$proto_field.ts

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

package/src/functional/$proto_float.ts

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

package/src/functional/$proto_i32.ts

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

package/src/functional/$proto_i64.ts

@@ -0,0 +1,37 @@
+export function $proto_i64_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: bigint,
+): number {
+    value = BigInt.asUintN(64, value);
+
+    dst[offset] = Number(value & BigInt(0xff));
+    dst[offset + 1] = Number((value >> BigInt(8)) & BigInt(0xff));
+    dst[offset + 2] = Number((value >> BigInt(16)) & BigInt(0xff));
+    dst[offset + 3] = Number((value >> BigInt(24)) & BigInt(0xff));
+    dst[offset + 4] = Number((value >> BigInt(32)) & BigInt(0xff));
+    dst[offset + 5] = Number((value >> BigInt(40)) & BigInt(0xff));
+    dst[offset + 6] = Number((value >> BigInt(48)) & BigInt(0xff));
+    dst[offset + 7] = Number((value >> BigInt(56)) & BigInt(0xff));
+    offset += 8;
+
+    return offset;
+}
+
+export function $proto_i64_decode(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    const value =
+        (BigInt(buf[offset]!) << BigInt(0)) |
+        (BigInt(buf[offset + 1]!) << BigInt(8)) |
+        (BigInt(buf[offset + 2]!) << BigInt(16)) |
+        (BigInt(buf[offset + 3]!) << BigInt(24)) |
+        (BigInt(buf[offset + 4]!) << BigInt(32)) |
+        (BigInt(buf[offset + 5]!) << BigInt(40)) |
+        (BigInt(buf[offset + 6]!) << BigInt(48)) |
+        (BigInt(buf[offset + 7]!) << BigInt(56));
+    offset += 8;
+
+    return [BigInt.asIntN(64, value), offset];
+}

package/src/functional/$proto_size.ts

@@ -0,0 +1,82 @@
+import { $proto_field_wiretype } from "./$proto_field";
+
+export function $proto_size_varint(n: number): number;
+export function $proto_size_varint(n: bigint): number;
+
+export function $proto_size_varint(n: number | bigint): number {
+    if (typeof n === "number") {
+        if (n < 0) {
+            return SizeVarInt64(BigInt(n));
+        }
+        return SizeVarInt32(n);
+    }
+
+    return SizeVarInt64(n);
+}
+
+export function $proto_size_field(
+    fieldNumber: number,
+    wireType: $proto_field_wiretype,
+): number {
+    const tag = (fieldNumber << 3) | Number(wireType);
+    return $proto_size_varint(tag);
+}
+
+export function $proto_size_bytes(len: number): number {
+    return $proto_size_varint(len) + len;
+}
+
+const utf8_encoder = new TextEncoder();
+
+export function $proto_size_string(value: string): number {
+    // TODO: optimize (DON'T ENCODE TEXT TWICE)
+    const bytes = utf8_encoder.encode(value);
+    return $proto_size_bytes(bytes.length);
+}
+
+function SizeVarInt32(value: number): number {
+    value = (value | 0) >>> 0; // 32-bit integer
+    // TODO: optimize ( branchless solution exists )
+    // TODO: try lookup table based solution
+
+    if (value <= 127) {
+        return 1;
+    } else if (value <= 16383) {
+        return 2;
+    } else if (value <= 2097151) {
+        return 3;
+    } else if (value <= 268435455) {
+        return 4;
+    }
+
+    // < 34359738367
+    return 5;
+}
+
+function SizeVarInt64(value: bigint): number {
+    value = BigInt.asUintN(64, value);
+    // TODO: optimize ( branchless solution exists )
+    // TODO: try lookup table based solution
+
+    if (value <= BigInt("127")) {
+        return 1;
+    } else if (value <= BigInt("16383")) {
+        return 2;
+    } else if (value <= BigInt("2097151")) {
+        return 3;
+    } else if (value <= BigInt("268435455")) {
+        return 4;
+    } else if (value <= BigInt("34359738367")) {
+        return 5;
+    } else if (value <= BigInt("4398046511103")) {
+        return 6;
+    } else if (value <= BigInt("562949953421311")) {
+        return 7;
+    } else if (value <= BigInt("72057594037927935")) {
+        return 8;
+    } else if (value <= BigInt("9223372036854775807")) {
+        return 9;
+    }
+
+    return 10;
+}

package/src/functional/$proto_string.ts

@@ -0,0 +1,24 @@
+import { $proto_bytes_decode, $proto_bytes_encode } from "./$proto_bytes";
+
+const utf8_encoder = new TextEncoder();
+
+export function $proto_string_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: string,
+): number {
+    // TODO: optimize (DON'T ENCODE TEXT TWICE)
+
+    const bytes = utf8_encoder.encode(value);
+    return $proto_bytes_encode(dst, offset, bytes);
+}
+
+export function $proto_string_decode(
+    src: Uint8Array,
+    offset: number,
+): [value: string, offset: number] {
+    const utf8_decoder = new TextDecoder("utf-8");
+    const [bytes, o] = $proto_bytes_decode(src, offset);
+    const value = utf8_decoder.decode(bytes);
+    return [value, o];
+}

package/src/functional/$varint.ts

@@ -0,0 +1,130 @@
+function EncodeVarNumber(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number {
+    value = (value | 0) >>> 0; // 32-bit integer
+
+    while (value > 127) {
+        dst[offset++] = (value & 0b01111111) | 0b10000000;
+        value >>>= 7;
+    }
+    dst[offset++] = value;
+
+    return offset;
+}
+
+function DecodeVarNumber(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    let value = 0;
+    let shift = 0;
+
+    while (true) {
+        const byte = buf[offset++]!;
+        value |= (byte & 0b01111111) << shift;
+        if (byte < 128) {
+            break;
+        }
+        shift += 7;
+    }
+
+    return [value | 0, offset];
+}
+
+function DecodeVarBigInt(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    let value = BigInt(0);
+    let shift = BigInt(0);
+
+    while (true) {
+        const byte = buf[offset++]!;
+        value |= BigInt(byte & 0b01111111) << shift;
+        if (byte < 128) {
+            break;
+        }
+        shift += BigInt(7);
+    }
+
+    return [BigInt.asIntN(64, value), offset];
+}
+
+export function $varint_decode_i32(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const [v, o] = DecodeVarNumber(buf, offset);
+    return [v, o];
+}
+
+export function $varint_decode_u32(
+    buf: Uint8Array,
+    offset: number,
+): [value: number, offset: number] {
+    const [v, o] = DecodeVarNumber(buf, offset);
+    return [v >>> 0, o];
+}
+
+export function $varint_decode_i64(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    const [v, o] = DecodeVarBigInt(buf, offset);
+    return [v, o];
+}
+
+export function $varint_decode_u64(
+    buf: Uint8Array,
+    offset: number,
+): [value: bigint, offset: number] {
+    const [v, o] = DecodeVarBigInt(buf, offset);
+    return [BigInt.asUintN(64, v), o];
+}
+
+function EncodeVarBigInt(
+    dst: Uint8Array,
+    offset: number,
+    value: bigint,
+): number {
+    value = BigInt.asUintN(64, value);
+
+    while (value > BigInt(127)) {
+        dst[offset++] = Number(value & BigInt(0b01111111)) | 0b10000000;
+        value >>= BigInt(7);
+    }
+    dst[offset++] = Number(value);
+
+    return offset;
+}
+
+export function $varint_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number;
+export function $varint_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: bigint,
+): number;
+
+export function $varint_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number | bigint,
+): number {
+    if (typeof value === "bigint") {
+        offset = EncodeVarBigInt(dst, offset, value);
+    } else {
+        if (value < 0) {
+            // NOTE: Protocol Buffers signed varint encoding uses two's complement of 64-bit unsigned integers.
+            offset = EncodeVarBigInt(dst, offset, BigInt(value));
+        } else {
+            offset = EncodeVarNumber(dst, offset, value);
+        }
+    }
+    return offset;
+}

package/src/functional/$zigzag.ts

@@ -0,0 +1,39 @@
+export function $zigzag_encode(value: number): number;
+export function $zigzag_encode(value: bigint): bigint;
+export function $zigzag_encode(value: number | bigint): any {
+    // TODO: optimize (branchless solution exists)
+
+    if (typeof value === "bigint") {
+        if (value < BigInt(0)) {
+            value = -value;
+            return value * BigInt(2) - BigInt(1);
+        }
+        return value * BigInt(2);
+    }
+
+    if (value < 0) {
+        value = -value;
+        return value * 2 - 1;
+    }
+    return value * 2;
+}
+
+export function $zigzag_decode(value: number): number;
+export function $zigzag_decode(value: bigint): bigint;
+export function $zigzag_decode(value: number | bigint): any {
+    // TODO: optimize (branchless solution exists)
+
+    if (typeof value === "bigint") {
+        value = BigInt.asUintN(64, value);
+        if (value & BigInt(1)) {
+            return -(value + BigInt(1)) / BigInt(2);
+        }
+        return value / BigInt(2);
+    }
+
+    value = value >>> 0;
+    if (value & 1) {
+        return -(value + 1) / 2;
+    }
+    return value / 2;
+}