typia 3.4.10 → 3.5.0-dev.20221219

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).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).getFloat32(offset, true);
+    offset += 4;
+    return [value, offset];
+}
+
+export function $proto_float64_encode(
+    dst: Uint8Array,
+    offset: number,
+    value: number,
+): number {
+    new DataView(dst).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).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;
+}

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,11 @@
+export interface IProtocolProperty {
+    key: string;
+    oneOf: IProtocolProperty.IOneOf[];
+    required: boolean;
+    repeated: boolean;
+}
+export namespace IProtocolProperty {
+    export interface IOneOf {
+        type: string;
+    }
+}

package/src/metadata/IMetadataTag.ts

@@ -10,14 +10,16 @@ export type IMetadataTag =
     | IMetadataTag.IMinLength
     | IMetadataTag.IMaxLength
     // NUMBER
-    | IMetadataTag.IType
+    | IMetadataTag.INumberType
     | IMetadataTag.IRange
     | IMetadataTag.IMinimum
     | IMetadataTag.IMaximum
     | IMetadataTag.IExclusiveMinimum
     | IMetadataTag.IExclusiveMaximum
     | IMetadataTag.IMultipleOf
-    | IMetadataTag.IStep;
+    | IMetadataTag.IStep
+    // BIGINT
+    | IMetadataTag.IBigintType;
 
 export namespace IMetadataTag {
     /* -----------------------------------------------------------
@@ -71,9 +73,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 IRange {
@@ -115,6 +125,11 @@ export namespace IMetadataTag {
     /* -----------------------------------------------------------
         MISCELLANEOUS
     ----------------------------------------------------------- */
+    export interface IBigintType {
+        kind: "type";
+        value: "int64" | "uint64";
+    }
+
     export interface ISign {
         include: boolean;
         value: number;

package/src/metadata/Metadata.ts

@@ -203,6 +203,7 @@ export class Metadata {
     public empty(): boolean {
         return this.bucket() === 0 || this.size() === 0;
     }
+
     public size(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -221,6 +222,7 @@ export class Metadata {
             this.maps.length
         );
     }
+
     public bucket(): number {
         return (
             (this.resolved ? 1 : 0) +
@@ -237,6 +239,7 @@ export class Metadata {
             (this.maps.length ? 1 : 0)
         );
     }
+
     public isConstant(): boolean {
         return this.bucket() === (this.constants.length ? 1 : 0);
     }
@@ -452,8 +455,7 @@ function getName(metadata: Metadata): string {
         elements.push(`Array<${array.getName()}>`);
 
     // OBJECT
-    for (const object of metadata.objects)
-        elements.push(`Resolve<${object.name}>`);
+    for (const object of metadata.objects) elements.push(object.name);
     if (metadata.resolved !== null) elements.push(metadata.resolved.getName());
 
     // NATIVES

package/src/module.ts

@@ -29,7 +29,9 @@ export * from "./IValidation";
     SINGLE FUNCTIONS
         - BASIC VALIDATORS
         - STRICT VALIDATORS
+        - PROTOCOL BUFFER FUNCTIONS
         - JSON FUNCTIONS
+        - MISC
 ==============================================================
     BASIC VALIDATORS
 ----------------------------------------------------------- */
@@ -587,6 +589,16 @@ export namespace validateEquals {
         };
 }
 
+/* -----------------------------------------------------------
+    PROTOCOL BUFFER FUNCTIONS
+----------------------------------------------------------- */
+export function message(): never;
+export function message<T>(): string;
+
+export function message(): string {
+    halt("message");
+}
+
 /* -----------------------------------------------------------
     JSON FUNCTIONS
 ----------------------------------------------------------- */

package/src/programmers/CheckerProgrammer.ts

@@ -415,10 +415,16 @@ export namespace CheckerProgrammer {
                         input,
                         [
                             {
-                                expression: ExpressionFactory.isObject(
-                                    input,
-                                    true,
-                                ),
+                                expression: ExpressionFactory.isObject(input, {
+                                    checkNull: true,
+                                    checkArray: meta.objects.some((obj) =>
+                                        obj.properties.every(
+                                            (prop) =>
+                                                !prop.key.isSoleLiteral() ||
+                                                !prop.value.required,
+                                        ),
+                                    ),
+                                }),
                                 combined: false,
                             },
                             {

package/src/programmers/IsProgrammer.ts

@@ -106,7 +106,10 @@ export namespace IsProgrammer {
                     const obj: MetadataObject = target.objects[0]!;
                     if (obj._Is_simple())
                         return ts.factory.createLogicalAnd(
-                            ExpressionFactory.isObject(input, true),
+                            ExpressionFactory.isObject(input, {
+                                checkNull: true,
+                                checkArray: false,
+                            }),
                             config.joiner.object(
                                 feature_object_entries(config as any)(obj)(
                                     input,

package/src/programmers/MessageProgrammer.ts

@@ -0,0 +1,110 @@
+import ts from "typescript";
+
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { ProtocolFactory } from "../factories/ProtocolFactory";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { IProject } from "../transformers/IProject";
+
+import { MapUtil } from "../utils/MapUtil";
+
+import { IProtocolMessage } from "../messages/IProtocolMessage";
+
+export namespace MessageProgrammer {
+    export const generate =
+        ({ checker }: IProject) =>
+        (type: ts.Type) => {
+            // PARSE TARGET TYPE
+            const collection: MetadataCollection = ProtocolFactory.collection();
+            const metadata: Metadata =
+                ProtocolFactory.metadata(checker)(collection)(type);
+
+            // CONVERT TO PROTOCOL MESSAGES
+            const dict: Map<string, IProtocolMessage> = new Map();
+            ProtocolFactory.generate(collection)(dict)(metadata);
+
+            // STRINGIFY
+            const hierarchies: Map<string, Hierarchy> = new Map();
+            for (const msg of dict.values()) emplace(hierarchies)(msg);
+
+            const content: string =
+                `syntax = "proto3";\n\n` +
+                [...hierarchies.values()]
+                    .map((hier) => stringify(hier))
+                    .join("\n\n");
+
+            // RETURNS
+            return ts.factory.createStringLiteral(content);
+        };
+
+    const stringify = (hierarchy: Hierarchy): string => {
+        const { key, message, children } = hierarchy;
+        let index: number = 1;
+
+        const elements: string[] = [`message ${key} {`];
+        if (message !== null)
+            elements.push(
+                ...message.properties.map((property) => {
+                    if (property.oneOf.length === 1)
+                        return [
+                            TAB,
+                            property.required ? "" : "optional ",
+                            property.repeated ? "repeated " : "",
+                            property.oneOf[0]!.type + " ",
+                            property.key + " ",
+                            "= ",
+                            `${index++};`,
+                        ].join("");
+                    return (
+                        `${TAB}oneof ${property.key} {\n` +
+                        property.oneOf
+                            .map(
+                                (o, i) =>
+                                    `${TAB}${TAB}${o.type} o${i} = ${index++};`,
+                            )
+                            .join("\n") +
+                        `\n${TAB}}`
+                    );
+                }),
+            );
+        if (message !== null && children.size) elements.push("\n");
+        if (children.size)
+            elements.push(
+                [...children.values()]
+                    .map((child) => stringify(child))
+                    .map((body) =>
+                        body
+                            .split("\n")
+                            .map((line) => `${TAB}${line}`)
+                            .join("\n"),
+                    )
+                    .join("\n\n"),
+            );
+        elements.push("}");
+
+        return elements.join("\n");
+    };
+
+    const emplace =
+        (dict: Map<string, Hierarchy>) => (message: IProtocolMessage) => {
+            const accessors: string[] = message.name.split(".");
+            accessors.forEach((access, i) => {
+                const hierarchy: Hierarchy = MapUtil.take(dict, access, () => ({
+                    key: access,
+                    message: null!,
+                    children: new Map(),
+                }));
+                dict = hierarchy.children;
+                if (i === accessors.length - 1) hierarchy.message = message;
+            });
+        };
+}
+
+interface Hierarchy {
+    key: string;
+    message: IProtocolMessage | null;
+    children: Map<string, Hierarchy>;
+}
+
+const TAB = " ".repeat(4);

package/src/programmers/StringifyProgrammer.ts

@@ -339,7 +339,17 @@ export namespace StringifyProgrammer {
             if (meta.objects.length)
                 unions.push({
                     type: "object",
-                    is: () => ExpressionFactory.isObject(input, true),
+                    is: () =>
+                        ExpressionFactory.isObject(input, {
+                            checkNull: true,
+                            checkArray: meta.objects.some((obj) =>
+                                obj.properties.every(
+                                    (prop) =>
+                                        !prop.key.isSoleLiteral() ||
+                                        !prop.value.required,
+                                ),
+                            ),
+                        }),
                     value: () =>
                         meta.isParentResolved() === false &&
                         meta.objects.length === 1 &&