typia 5.0.0-dev.20230814-2 → 5.0.0-dev.20230819

package/src/functional/$ProtobufSizer.ts

@@ -0,0 +1,144 @@
+import { $strlen } from "./$strlen";
+import { IProtobufWriter } from "./IProtobufWriter";
+
+export class $ProtobufSizer implements IProtobufWriter {
+    /**
+     * Total length.
+     */
+    public len: number;
+
+    /**
+     * Position stack.
+     */
+    public readonly pos: Array<number>;
+
+    /**
+     * Variable length list.
+     */
+    public readonly varlen: Array<number>;
+
+    /**
+     * Variable length index stack.
+     */
+    public readonly varlenidx: Array<number>;
+
+    public constructor(length: number = 0) {
+        this.len = length;
+        this.pos = [];
+        this.varlen = [];
+        this.varlenidx = [];
+    }
+
+    public bool(): void {
+        this.len += 1;
+    }
+    public int32(value: number): void {
+        if (value < 0) {
+            // 10 bytes to encode negative number
+            this.len += 10;
+        } else {
+            this.varint32(value);
+        }
+    }
+    public sint32(value: number): void {
+        this.varint32((value << 1) ^ (value >> 31));
+    }
+    public uint32(value: number): void {
+        this.varint32(value);
+    }
+
+    public int64(value: bigint | number): void {
+        this.varint64(typeof value === "number" ? BigInt(value) : value);
+    }
+    public sint64(value: bigint | number): void {
+        if (typeof value === "number") value = BigInt(value);
+        this.varint64((value << BigInt(1)) ^ (value >> BigInt(63)));
+    }
+    public uint64(value: bigint | number): void {
+        this.varint64(typeof value === "number" ? BigInt(value) : value);
+    }
+
+    // public fixed32(_value: number): void {
+    //     this.len += 4;
+    // }
+    // public sfixed32(_value: number): void {
+    //     this.len += 4;
+    // }
+    // public fixed64(_value: number | bigint): void {
+    //     this.len += 8;
+    // }
+    // public sfixed64(_value: number | bigint): void {
+    //     this.len += 8;
+    // }
+    public float(_value: number): void {
+        this.len += 4;
+    }
+    public double(_value: number): void {
+        this.len += 8;
+    }
+
+    public bytes(value: Uint8Array): void {
+        this.uint32(value.byteLength);
+        this.len += value.byteLength;
+    }
+    public string(value: string): void {
+        const len: number = $strlen(value);
+        this.varlen.push(len);
+        this.uint32(len);
+        this.len += len;
+    }
+
+    public fork(): void {
+        this.pos.push(this.len); // save current position
+        this.varlenidx.push(this.varlen.length); // save current index in varlen array
+        this.varlen.push(0); // add 0 length to varlen array (to be updated in ldelim())
+    }
+
+    public ldelim(): void {
+        if (!(this.pos.length && this.varlenidx.length))
+            throw new Error("Missing fork() before ldelim() call.");
+
+        const endPos = this.len; // current position is end position
+        const startPos = this.pos.pop()!; // get start position from stack
+        const idx = this.varlenidx.pop()!; // get varlen index from stack
+        const len = endPos - startPos; // calculate length
+
+        this.varlen[idx] = len; // update variable length
+        this.uint32(len); // add uint32 that should be called in fork()
+    }
+
+    public reset(): void {
+        this.len = 0;
+        // re-use arrays
+        this.pos.length = 0;
+        this.varlen.length = 0;
+        this.varlenidx.length = 0;
+    }
+
+    private varint32(value: number): void {
+        this.len +=
+            value < 0
+                ? 10 // 10 bits with leading 1's
+                : value < 0x80
+                ? 1
+                : value < 0x4000
+                ? 2
+                : value < 0x200000
+                ? 3
+                : value < 0x10000000
+                ? 4
+                : 5;
+    }
+
+    private varint64(val: bigint): void {
+        val = BigInt.asUintN(64, val);
+        while (val > NX7F) {
+            ++this.len;
+            val = val >> ND07;
+        }
+        ++this.len;
+    }
+}
+
+const ND07 = BigInt(7);
+const NX7F = BigInt(0x7f);

package/src/functional/$ProtobufWriter.ts

@@ -0,0 +1,152 @@
+import { $ProtobufSizer } from "./$ProtobufSizer";
+import { IProtobufWriter } from "./IProtobufWriter";
+
+export class $ProtobufWriter implements IProtobufWriter {
+    /**
+     * Related sizer
+     */
+    private readonly sizer: $ProtobufSizer;
+
+    /**
+     * Current pointer.
+     */
+    private ptr: number;
+
+    /**
+     * Protobuf buffer.
+     */
+    private buf: Uint8Array;
+
+    /**
+     * DataView for buffer.
+     */
+    private view: DataView;
+
+    /**
+     * Index in varlen array from sizer.
+     */
+    private varlenidx: number;
+
+    constructor(sizer: $ProtobufSizer) {
+        this.sizer = sizer;
+        this.buf = new Uint8Array(sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+
+    buffer(): Uint8Array {
+        return this.buf;
+    }
+
+    bool(value: boolean): void {
+        this.byte(value ? 1 : 0);
+    }
+
+    byte(value: number): void {
+        this.buf[this.ptr++] = value & 255;
+    }
+
+    int32(value: number): void {
+        if (value < 0) this.int64(value);
+        else this.variant32(value >>> 0);
+    }
+
+    sint32(value: number): void {
+        this.variant32((value << 1) ^ (value >> 31));
+    }
+
+    uint32(value: number): void {
+        this.variant32(value);
+    }
+
+    sint64(value: number | bigint): void {
+        value = BigInt(value);
+        this.variant64((value << ND01) ^ (value >> ND63));
+    }
+
+    int64(value: number | bigint): void {
+        this.variant64(BigInt(value));
+    }
+
+    uint64(value: number | bigint): void {
+        this.variant64(BigInt(value));
+    }
+
+    float(val: number): void {
+        this.view.setFloat32(this.ptr, val, true);
+        this.ptr += 4;
+    }
+
+    double(val: number): void {
+        this.view.setFloat64(this.ptr, val, true);
+        this.ptr += 8;
+    }
+
+    bytes(value: Uint8Array): void {
+        this.fork();
+        this.uint32(value.byteLength);
+        for (let i = 0; i < value.byteLength; i++)
+            this.buf[this.ptr++] = value[i]!;
+    }
+
+    string(value: string): void {
+        const len: number = this.varlen(); // use precomputed length
+        this.uint32(len);
+
+        const binary: Uint8Array = utf8.encode(value);
+        for (let i = 0; i < binary.byteLength; i++)
+            this.buf[this.ptr++] = binary[i]!;
+    }
+
+    fork(): void {
+        this.uint32(this.varlen()); // use precomputed length
+    }
+
+    ldelim(): void {
+        // nothing to do - all dirty work done by sizer
+    }
+
+    finish(): Uint8Array {
+        return this.buf;
+    }
+
+    reset(): void {
+        this.buf = new Uint8Array(this.sizer.len);
+        this.view = new DataView(this.buf.buffer);
+        this.ptr = 0;
+        this.varlenidx = 0;
+    }
+
+    private variant32(val: number): void {
+        while (val > 0x7f) {
+            this.buf[this.ptr++] = (val & 0x7f) | 0x80;
+            val = val >>> 7;
+        }
+        this.buf[this.ptr++] = val;
+    }
+
+    private variant64(val: bigint): void {
+        val = BigInt.asUintN(64, val);
+        while (val > NX7F) {
+            this.buf[this.ptr++] = Number((val & NX7F) | NX80);
+            val = val >> ND07; // @todo
+            // (val / (128n) % 2n === 1n)
+        }
+        this.buf[this.ptr++] = Number(val);
+    }
+
+    private varlen(): number {
+        return this.varlenidx >= this.sizer.varlen.length
+            ? 0
+            : this.sizer.varlen[this.varlenidx++]!;
+    }
+}
+
+const utf8 = new TextEncoder();
+
+const ND01 = BigInt(1);
+const ND07 = BigInt(7);
+const ND63 = BigInt(63);
+const NX7F = BigInt(0x7f);
+const NX80 = BigInt(0x80);

package/src/functional/IProtobufWriter.ts

@@ -0,0 +1,18 @@
+export interface IProtobufWriter {
+    bool(value: boolean): void;
+    int32(value: number): void;
+    sint32(value: number): void;
+    uint32(value: number): void;
+
+    int64(value: bigint | number): void;
+    sint64(value: bigint | number): void;
+    uint64(value: bigint | number): void;
+
+    float(value: number): void;
+    double(value: number): void;
+    bytes(value: Uint8Array): void;
+    string(value: string): void;
+
+    fork(): void;
+    ldelim(): void;
+}

package/src/functional/Namespace.ts

@@ -1,9 +1,10 @@
-import { Writer } from "protobufjs";
-
 import { RandomGenerator } from "../utils/RandomGenerator";
 
 import { IValidation } from "../IValidation";
 import { TypeGuardError } from "../TypeGuardError";
+import { $ProtobufReader } from "./$ProtobufReader";
+import { $ProtobufSizer } from "./$ProtobufSizer";
+import { $ProtobufWriter } from "./$ProtobufWriter";
 import { $any } from "./$any";
 import { $every } from "./$every";
 import { $guard } from "./$guard";
@@ -101,14 +102,20 @@ export namespace Namespace {
             string: $string,
             tail: $tail,
             rest: $rest,
-            throws: $throws(method),
+            throws: $throws(`json.${method}`),
         });
     }
 
     export namespace protobuf {
+        export const decode = (method: string) => ({
+            Reader: $ProtobufReader,
+            throws: $throws(`protobuf.${method}`),
+        });
+
         export const encode = (method: string) => ({
-            Writer: Writer,
-            strl: $strlen,
+            Sizer: $ProtobufSizer,
+            Writer: $ProtobufWriter,
+            strlen: $strlen,
             throws: $throws(method),
         });
     }
@@ -116,13 +123,13 @@ export namespace Namespace {
     export namespace misc {
         export const clone = (method: string) => ({
             ...is(),
-            throws: $throws(method),
+            throws: $throws(`misc.${method}`),
             any: $any,
         });
 
         export const prune = (method: string) => ({
             ...is(),
-            throws: $throws(method),
+            throws: $throws(`misc.${method}`),
         });
     }
 

package/src/programmers/FeatureProgrammer.ts

@@ -278,9 +278,9 @@ export namespace FeatureProgrammer {
         (collection: MetadataCollection) =>
             collection
                 .objects()
-                .map((obj, i) =>
+                .map((obj) =>
                     StatementFactory.constant(
-                        `${config.prefix}o${i}`,
+                        `${config.prefix}o${obj.index}`,
                         ts.factory.createArrowFunction(
                             undefined,
                             undefined,

package/src/programmers/helpers/CloneJoiner.ts

@@ -32,7 +32,6 @@ export namespace CloneJoiner {
         if (dynamic.length === 0) return literal;
 
         const key = ts.factory.createIdentifier("key");
-        const value = ts.factory.createIdentifier("value");
         const output = ts.factory.createIdentifier("output");
 
         const statements: ts.Statement[] = dynamic.map((entry) =>
@@ -72,30 +71,7 @@ export namespace CloneJoiner {
             ),
             ts.factory.createForOfStatement(
                 undefined,
-                ts.factory.createVariableDeclarationList(
-                    [
-                        ts.factory.createVariableDeclaration(
-                            ts.factory.createArrayBindingPattern([
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    key,
-                                    undefined,
-                                ),
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    value,
-                                    undefined,
-                                ),
-                            ]),
-                            undefined,
-                            undefined,
-                            undefined,
-                        ),
-                    ],
-                    ts.NodeFlags.Const,
-                ),
+                StatementFactory.entry("key")("value"),
                 ts.factory.createCallExpression(
                     ts.factory.createIdentifier("Object.entries"),
                     undefined,

package/src/programmers/helpers/FunctionImporeter.ts

@@ -29,7 +29,10 @@ export class FunctionImporter {
         return this.local_.has(name);
     }
 
-    public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
+    public declare(
+        modulo: ts.LeftHandSideExpression,
+        includeUnions: boolean = true,
+    ): ts.Statement[] {
         return [
             ...[...this.used_].map((name) =>
                 StatementFactory.constant(
@@ -44,12 +47,20 @@ export class FunctionImporter {
                     )(name),
                 ),
             ),
-            ...[...this.unions_.values()].map(([key, arrow]) =>
-                StatementFactory.constant(key, arrow),
-            ),
+            ...(includeUnions === true
+                ? [...this.unions_.values()].map(([key, arrow]) =>
+                      StatementFactory.constant(key, arrow),
+                  )
+                : []),
         ];
     }
 
+    public declareUnions(): ts.Statement[] {
+        return [...this.unions_.values()].map(([key, arrow]) =>
+            StatementFactory.constant(key, arrow),
+        );
+    }
+
     public increment(): number {
         return ++this.sequence_;
     }

package/src/programmers/helpers/ProtobufWire.ts

@@ -1,28 +1,34 @@
 export const enum ProtobufWire {
     /**
-     * integers
-     * bool
-     * enum
+     * - integers
+     * - bool
+     * - enum
      */
-    VARINT = 0,
+    VARIANT = 0,
 
     /**
-     * fixed64
-     * sfixed64
-     * double
+     * - fixed64
+     * - sfixed64
+     * - double
      */
     I64 = 1,
 
     /**
-     * string
-     * bytes
-     * mebedded messages
-     * packed repeated fields
+     * - string
+     * - bytes
+     * - mebedded messages
+     * - packed repeated fields
      */
     LEN = 2,
 
+    START_GROUP = 3,
+
+    END_GROUP = 4,
+
     /**
-     * fixed, sfixed32, float
+     * - fixed
+     * - sfixed32
+     * - float
      */
     I32 = 5,
 }

package/src/programmers/helpers/UnionExplorer.ts

@@ -73,9 +73,9 @@ export namespace UnionExplorer {
             );
 
             // DO SPECIALIZE
-            const conditions: ts.IfStatement[] = specList
+            const condition: ts.IfStatement = specList
                 .filter((spec) => spec.property.key.getSoleLiteral() !== null)
-                .map((spec) => {
+                .map((spec, i, array) => {
                     const key: string = spec.property.key.getSoleLiteral()!;
                     const accessor: ts.Expression =
                         IdentifierFactory.access(input)(key);
@@ -105,21 +105,8 @@ export namespace UnionExplorer {
                                 jsDocTags,
                             ),
                         ),
-                    );
-                });
-
-            // RETURNS WITH CONDITIONS
-            return ts.factory.createCallExpression(
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(
-                        [
-                            ...conditions,
-                            remained.length
+                        i === array.length - 1
+                            ? remained.length
                                 ? ts.factory.createReturnStatement(
                                       object(config, level + 1)(
                                           input,
@@ -133,10 +120,28 @@ export namespace UnionExplorer {
                                       input,
                                       expected,
                                       explore,
-                                  ),
-                        ],
-                        true,
+                                  )
+                            : undefined,
+                    );
+                })
+                .reverse()
+                .reduce((a, b) =>
+                    ts.factory.createIfStatement(
+                        b.expression,
+                        b.thenStatement,
+                        a,
                     ),
+                );
+
+            // RETURNS WITH CONDITIONS
+            return ts.factory.createCallExpression(
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock([condition], true),
                 ),
                 undefined,
                 undefined,

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -12,6 +12,7 @@ const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
     useLocal: (name: string): string => importer.useLocal(name),
     hasLocal: (name: string): boolean => importer.hasLocal(name),
     declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+    declareUnions: (): ts.Statement[] => [],
     increment: (): number => importer.increment(),
     emplaceUnion: (
         prefix: string,

package/src/programmers/internal/decode_union_object.ts

@@ -55,13 +55,24 @@ const iterate =
     (input: ts.Expression, unions: IUnion[], expected: string) =>
         ts.factory.createBlock(
             [
-                ...unions.map((u) =>
-                    ts.factory.createIfStatement(
-                        u.is(),
-                        ts.factory.createReturnStatement(u.value()),
+                unions
+                    .map((u, i) =>
+                        ts.factory.createIfStatement(
+                            u.is(),
+                            ts.factory.createReturnStatement(u.value()),
+                            i === unions.length - 1
+                                ? escaper(input, expected)
+                                : undefined,
+                        ),
+                    )
+                    .reverse()
+                    .reduce((a, b) =>
+                        ts.factory.createIfStatement(
+                            b.expression,
+                            b.thenStatement,
+                            a,
+                        ),
                     ),
-                ),
-                escaper(input, expected),
             ],
             true,
         );