typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/functional/$proto_field.ts

@@ -1,30 +0,0 @@
-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 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

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

package/src/messages/IProtocolMessage.ts

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

package/src/messages/IProtocolProperty.ts

@@ -1,13 +0,0 @@
-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/programmers/MessageProgrammer.ts

@@ -1,126 +0,0 @@
-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 { Escaper } from "../utils/Escaper";
-import { MapUtil } from "../utils/MapUtil";
-import { NameEncoder } from "../utils/NameEncoder";
-
-import { IProtocolMap } from "../messages/IProtocolMap";
-import { IProtocolMessage } from "../messages/IProtocolMessage";
-
-export namespace MessageProgrammer {
-    export const generate =
-        ({ checker }: IProject) =>
-        (type: ts.Type) => {
-            // PARSE TARGET TYPE
-            const collection: MetadataCollection = new MetadataCollection();
-            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 ${NameEncoder.encode(key)} {`];
-        if (message !== null)
-            elements.push(
-                ...message.properties.map((property) => {
-                    const key: string =
-                        Escaper.variable(property.key) &&
-                        property.key.indexOf("$") === -1
-                            ? property.key
-                            : `v${index + 1}`;
-                    if (property.oneOf.length === 1)
-                        return [
-                            TAB,
-                            property.required ? "" : "optional ",
-                            property.repeated ? "repeated " : "",
-                            getTypeName(property.oneOf[0]!.type) + " ",
-                            key,
-                            " = ",
-                            `${index++};`,
-                        ].join("");
-                    return (
-                        `${TAB}oneof ${key} {\n` +
-                        property.oneOf
-                            .map(
-                                (o, i) =>
-                                    `${TAB}${TAB}${getTypeName(
-                                        o.type,
-                                    )} ${key}_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;
-            });
-        };
-
-    function getTypeName(type: string | IProtocolMap): string {
-        return typeof type === "string"
-            ? NameEncoder.encode(type)
-            : `map<${type.key}, ${getTypeName(type.value)}>`;
-    }
-}
-
-interface Hierarchy {
-    key: string;
-    message: IProtocolMessage | null;
-    children: Map<string, Hierarchy>;
-}
-
-const TAB = " ".repeat(4);

package/src/transformers/features/protocols/MessageTransformer.ts

@@ -1,31 +0,0 @@
-import ts from "typescript";
-
-import { MessageProgrammer } from "../../../programmers/MessageProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace MessageTransformer {
-    export const transform =
-        (project: IProject) =>
-        (_modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-            // GET TYPE INFO
-            const type: ts.Type = project.checker.getTypeFromTypeNode(
-                expression.typeArguments[0],
-            );
-            if (type.isTypeParameter())
-                throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return MessageProgrammer.generate(project)(type);
-        };
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.message(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.message(): non-specified generic argument.",
-}

package/src/utils/NameEncoder.ts

@@ -1,32 +0,0 @@
-export namespace NameEncoder {
-    export function encode(str: string): string {
-        for (const [before, after] of REPLACERS)
-            str = str.split(before).join(after);
-        return str;
-    }
-
-    export function decode(str: string): string {
-        for (const [before, after] of REPLACERS)
-            if (after !== "") str = str.split(after).join(before);
-        return str;
-    }
-}
-
-const REPLACERS: [string, string][] = [
-    ["$", "_dollar_"],
-    ["&", "_and_"],
-    ["|", "_or_"],
-    ["{", "_blt_"],
-    ["}", "_bgt_"],
-    ["<", "_lt_"],
-    [">", "_gt_"],
-    ["(", "_lp_"],
-    [")", "_rp_"],
-    ["[", "_alt_"],
-    ["]", "_agt_"],
-    [",", "_comma_"],
-    ["`", "_backquote_"],
-    ["'", "_singlequote_"],
-    ['"', "_doublequote_"],
-    [" ", "_space_"],
-];