typia 3.8.4 → 4.0.0-dev.20230502

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

package/src/messages/IProtocolMap.ts

@@ -0,0 +1,5 @@
+export interface IProtocolMap {
+    type: "map";
+    key: string;
+    value: string | IProtocolMap;
+}

package/src/messages/IProtocolMessage.ts

@@ -0,0 +1,6 @@
+import { IProtocolProperty } from "./IProtocolProperty";
+
+export interface IProtocolMessage {
+    name: string;
+    properties: IProtocolProperty[];
+}

package/src/messages/IProtocolProperty.ts

@@ -0,0 +1,13 @@
+import { IProtocolMap } from "./IProtocolMap";
+
+export interface IProtocolProperty {
+    key: string;
+    oneOf: IProtocolProperty.IOneOf[];
+    required: boolean;
+    repeated: boolean;
+}
+export namespace IProtocolProperty {
+    export interface IOneOf {
+        type: string | IProtocolMap;
+    }
+}

package/src/metadata/IMetadata.ts

@@ -1,26 +1,26 @@
-import { Atomic } from "../typings/Atomic";
-
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataEntry } from "./IMetadataEntry";
-
-export interface IMetadata {
-    any: boolean;
-    required: boolean;
-    optional: boolean;
-    nullable: boolean;
-    functional: boolean;
-
-    atomics: Atomic.Literal[];
-    constants: IMetadataConstant[];
-    templates: IMetadata[][];
-    resolved: IMetadata | null;
-
-    rest: IMetadata | null;
-    arrays: IMetadata[];
-    tuples: IMetadata[][];
-    objects: string[];
-
-    natives: string[];
-    sets: IMetadata[];
-    maps: IMetadataEntry[];
-}
+import { Atomic } from "../typings/Atomic";
+
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEntry } from "./IMetadataEntry";
+
+export interface IMetadata {
+    any: boolean;
+    required: boolean;
+    optional: boolean;
+    nullable: boolean;
+    functional: boolean;
+
+    atomics: Atomic.Literal[];
+    constants: IMetadataConstant[];
+    templates: IMetadata[][];
+    resolved: IMetadata | null;
+
+    rest: IMetadata | null;
+    arrays: IMetadata[];
+    tuples: IMetadata[][];
+    objects: string[];
+
+    natives: string[];
+    sets: IMetadata[];
+    maps: IMetadataEntry[];
+}

package/src/metadata/IMetadataTag.ts

@@ -1,6 +1,6 @@
 export type IMetadataTag =
     // NUMBER
-    | IMetadataTag.IType
+    | IMetadataTag.INumberType
     | IMetadataTag.IMinimum
     | IMetadataTag.IMaximum
     | IMetadataTag.IExclusiveMinimum
@@ -22,9 +22,17 @@ export namespace IMetadataTag {
     /* -----------------------------------------------------------
         NUMBER
     ----------------------------------------------------------- */
-    export interface IType {
+    export interface INumberType {
         kind: "type";
-        value: "int" | "uint";
+        value:
+            | "int"
+            | "uint"
+            | "int32"
+            | "uint32"
+            | "int64"
+            | "uint64"
+            | "float"
+            | "double";
     }
 
     export interface IMinimum {