@rikaidev/yomi 0.2.6

package/dist/line/core/thrift/compact/type-codec-dsl.js

@@ -0,0 +1,66 @@
+import { THRIFT_TYPE } from '../types.js';
+export const COMPACT_TYPE_CODEC_DEFINITIONS = [
+    {
+        type: THRIFT_TYPE.BOOL,
+        readHandler: 'readBoolValue',
+        writeHandler: 'writeBoolValue',
+    },
+    {
+        type: THRIFT_TYPE.BYTE,
+        readHandler: 'readByteValue',
+        writeHandler: 'writeByteValue',
+    },
+    {
+        type: THRIFT_TYPE.I16,
+        readHandler: 'readI16Value',
+        writeHandler: 'writeI16Value',
+    },
+    {
+        type: THRIFT_TYPE.I32,
+        readHandler: 'readI32Value',
+        writeHandler: 'writeI32Value',
+    },
+    {
+        type: THRIFT_TYPE.I64,
+        readHandler: 'readI64Value',
+        writeHandler: 'writeI64Value',
+    },
+    {
+        type: THRIFT_TYPE.STRING,
+        readHandler: 'readStringValue',
+        writeHandler: 'writeStringValue',
+    },
+];
+export const COMPACT_STRUCT_TYPE_DEFINITIONS = [
+    { type: 0, handler: 'readNullValue' },
+    { type: 1, handler: 'readTrueValue' },
+    { type: 2, handler: 'readFalseValue' },
+    { type: 3, handler: 'readByteValue' },
+    { type: 4, handler: 'readI16Value' },
+    { type: 5, handler: 'readI32Value' },
+    { type: 6, handler: 'readI64Value' },
+    { type: 7, handler: 'readDoubleValue' },
+    { type: 8, handler: 'readStringValue' },
+    { type: 9, handler: 'readCollectionValue' },
+    { type: 10, handler: 'readCollectionValue' },
+    { type: 11, handler: 'readMapValue' },
+    { type: 12, handler: 'readStructValue' },
+];
+/**
+ * Resolve one compact thrift type into its configured codec definition.
+ *
+ * @param type - Thrift wire type.
+ * @returns Codec definition, if defined.
+ */
+export function getCompactTypeCodecDefinition(type) {
+    return (COMPACT_TYPE_CODEC_DEFINITIONS.find((candidate) => candidate.type === type) ?? null);
+}
+/**
+ * Resolve one compact struct field type into its configured reader handler.
+ *
+ * @param type - Compact field type.
+ * @returns Handler definition, if defined.
+ */
+export function getCompactStructTypeDefinition(type) {
+    return (COMPACT_STRUCT_TYPE_DEFINITIONS.find((candidate) => candidate.type === type) ?? null);
+}

package/dist/line/core/thrift/fields/builders.js

@@ -0,0 +1,124 @@
+/**
+ * TCompact field builders.
+ */
+/**
+ * Build a generic thrift field tuple.
+ *
+ * @param type - Thrift wire type.
+ * @param fieldId - Thrift field ID.
+ * @param value - Field value.
+ * @returns Thrift field tuple.
+ */
+export function field(type, fieldId, value) {
+    return [type, fieldId, value];
+}
+/**
+ * Build a BOOL field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param value - Boolean value.
+ * @returns Thrift field tuple.
+ */
+export function boolField(fieldId, value) {
+    return field(2, fieldId, value);
+}
+/**
+ * Build a BYTE field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param value - Byte value.
+ * @returns Thrift field tuple.
+ */
+export function byteField(fieldId, value) {
+    return field(3, fieldId, value);
+}
+/**
+ * Build an I16 field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param value - I16 value.
+ * @returns Thrift field tuple.
+ */
+export function i16Field(fieldId, value) {
+    return field(6, fieldId, value);
+}
+/**
+ * Build an I32 field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param value - I32 value.
+ * @returns Thrift field tuple.
+ */
+export function i32Field(fieldId, value) {
+    return field(8, fieldId, value);
+}
+/**
+ * Build an I64 field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param value - I64 value.
+ * @returns Thrift field tuple.
+ */
+export function i64Field(fieldId, value) {
+    return field(10, fieldId, value);
+}
+/**
+ * Build a STRING/BINARY field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param value - String or buffer value.
+ * @returns Thrift field tuple.
+ */
+export function stringField(fieldId, value) {
+    return field(11, fieldId, value);
+}
+/**
+ * Build a STRUCT field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param fields - Nested struct fields.
+ * @returns Thrift field tuple.
+ */
+export function structField(fieldId, fields) {
+    return field(12, fieldId, fields);
+}
+/**
+ * Build a MAP field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param keyType - Key thrift type.
+ * @param valueType - Value thrift type.
+ * @param entries - Map entries.
+ * @returns Thrift field tuple.
+ */
+export function mapField(fieldId, keyType, valueType, entries) {
+    return field(13, fieldId, [keyType, valueType, entries]);
+}
+/**
+ * Build a LIST field tuple.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param elementType - Element thrift type.
+ * @param items - List items.
+ * @returns Thrift field tuple.
+ */
+export function listField(fieldId, elementType, items) {
+    return field(15, fieldId, [elementType, items]);
+}
+/**
+ * Build a SET field tuple.
+ *
+ * A thrift SET (type 14) is wire-identical to a LIST in TCompact — same
+ * element-type/count header and element payload — only the field header's
+ * type nibble differs. LINE distinguishes them: e.g. inviteIntoChat /
+ * deleteOtherFromChat / createChat read `targetUserMids` as a SET and see an
+ * empty collection if it arrives as a LIST.
+ *
+ * @param fieldId - Thrift field ID.
+ * @param elementType - Element thrift type.
+ * @param items - Set items.
+ * @returns Thrift field tuple.
+ */
+export function setField(fieldId, elementType, items) {
+    return field(14, fieldId, [elementType, items]);
+}

package/dist/line/core/thrift/index.js

@@ -0,0 +1,12 @@
+/**
+ * Thrift - exports all modules
+ */
+export { TBinaryReader } from './binary/binary-reader.js';
+export { TBinaryWriter } from './binary/binary-writer.js';
+export { TCompactReader } from './compact/compact-reader.js';
+export { TCompactWriter } from './compact/compact-writer.js';
+export { boolField, byteField, field, i16Field, i32Field, i64Field, listField, mapField, setField, stringField, structField, } from './fields/builders.js';
+export { decodeResponseMessage } from './message/decoder.js';
+export { encodeCallMessage } from './message/encoder.js';
+export { readStructFields } from './struct/reader.js';
+export { MSG_TYPE, THRIFT_TYPE } from './types.js';

package/dist/line/core/thrift/message/decoder.js

@@ -0,0 +1,55 @@
+/**
+ * TCompact response message decoder.
+ */
+import { readStructFields } from '../struct/reader.js';
+/**
+ * Decode a full TCompact response message from raw bytes.
+ *
+ * Parses the 2-byte protocol header, varint seqId, varint+bytes method name,
+ * then delegates struct body parsing to readStructFields().
+ *
+ * @param data - Raw response bytes from the LINE server
+ * @returns Decoded message with fields map, or an error object
+ */
+export function decodeResponseMessage(data) {
+    if (!data || data.length < 2 || data[0] !== 0x82) {
+        throw new Error('invalid');
+    }
+    let pos = 1;
+    const typeByte = data[pos++];
+    const msgType = (typeByte >> 5) & 0x07;
+    let seqId = 0;
+    let shift = 0;
+    while (pos < data.length) {
+        const b = data[pos++];
+        seqId |= (b & 0x7f) << shift;
+        if (!(b & 0x80)) {
+            break;
+        }
+        shift += 7;
+    }
+    let nameLen = 0;
+    shift = 0;
+    while (pos < data.length) {
+        const b = data[pos++];
+        nameLen |= (b & 0x7f) << shift;
+        if (!(b & 0x80)) {
+            break;
+        }
+        shift += 7;
+    }
+    const name = new TextDecoder().decode(data.subarray(pos, pos + nameLen));
+    pos += nameLen;
+    const fields = readStructFields(data.subarray(pos), true);
+    const typeNames = {
+        1: 'CALL',
+        2: 'REPLY',
+        3: 'EXCEPTION',
+    };
+    return {
+        type: typeNames[msgType] || `?${msgType}`,
+        method: name,
+        seqId,
+        fields,
+    };
+}

package/dist/line/core/thrift/message/encoder.js

@@ -0,0 +1,25 @@
+/**
+ * LINE Thrift TCompact message encoder.
+ */
+import { Buffer } from 'node:buffer';
+import { varint } from '../primitives/varint.js';
+import { writeFieldsArray } from '../struct/writer.js';
+/**
+ * Build a TCompact CALL message using array-style field definitions.
+ *
+ * @param method - Method name.
+ * @param seqId - Sequence ID.
+ * @param args - Array of [type, fieldId, value] tuples.
+ * @returns Serialized TCompact message as Buffer.
+ */
+export function encodeCallMessage(method, seqId, args) {
+    const methodName = Buffer.from(method, 'utf-8');
+    return Buffer.concat([
+        Buffer.from([0x82, 0x21]),
+        varint(seqId),
+        varint(methodName.length),
+        methodName,
+        args?.length ? writeFieldsArray(args, { v: 0 }) : Buffer.alloc(0),
+        Buffer.from([0]),
+    ]);
+}

package/dist/line/core/thrift/primitives/varint.js

@@ -0,0 +1,64 @@
+/**
+ * TCompact primitive encoding helpers.
+ */
+import { Buffer } from 'node:buffer';
+/**
+ * Encode an unsigned integer as a base-128 varint.
+ *
+ * @param value - The number to encode.
+ * @returns Encoded varint buffer.
+ */
+export function varint(value) {
+    const bytes = [];
+    let remaining = value >>> 0;
+    do {
+        let byte = remaining & 0x7f;
+        remaining >>>= 7;
+        if (remaining) {
+            byte |= 0x80;
+        }
+        bytes.push(byte);
+    } while (remaining);
+    return Buffer.from(bytes);
+}
+/**
+ * Encode a signed 32-bit integer using ZigZag encoding.
+ *
+ * @param value - Signed 32-bit integer.
+ * @returns Encoded varint buffer.
+ */
+export function zigzag(value) {
+    return varint(((value << 1) ^ (value >> 31)) >>> 0);
+}
+/**
+ * Encode an unsigned bigint as a base-128 varint.
+ *
+ * @param value - Bigint to encode.
+ * @returns Encoded varint buffer.
+ */
+export function varintBig(value) {
+    const bytes = [];
+    let remaining = value;
+    if (remaining < 0n) {
+        remaining += 1n << 64n;
+    }
+    do {
+        let byte = Number(remaining & 0x7fn);
+        remaining >>= 7n;
+        if (remaining) {
+            byte |= 0x80;
+        }
+        bytes.push(byte);
+    } while (remaining);
+    return Buffer.from(bytes);
+}
+/**
+ * Encode a signed 64-bit integer using ZigZag encoding.
+ *
+ * @param value - Signed 64-bit integer.
+ * @returns Encoded varint buffer.
+ */
+export function zigzag64(value) {
+    const bigintValue = BigInt(value);
+    return varintBig((bigintValue << 1n) ^ (bigintValue >> 63n));
+}

package/dist/line/core/thrift/struct/reader.js

@@ -0,0 +1,172 @@
+/**
+ * TCompact struct parser.
+ */
+import { Buffer } from 'node:buffer';
+import { getCompactStructTypeDefinition } from '../compact/type-codec-dsl.js';
+/**
+ * Parse a TCompact struct from raw bytes (no message header).
+ *
+ * @param buf - Raw bytes starting at the first field header (or STOP byte)
+ * @param textStrings - If true, decode STRING fields as UTF-8 string (default: false → Buffer)
+ * @returns Object mapping field ID → parsed value
+ */
+export function readStructFields(buf, textStrings = false) {
+    let pos = 0;
+    let lastFieldId = 0;
+    let lastType = -1;
+    const readByte = () => buf[pos++];
+    const readVarint = () => {
+        let result = 0;
+        let shift = 0;
+        while (pos < buf.length) {
+            const byte = buf[pos++];
+            result |= (byte & 0x7f) << shift;
+            if (!(byte & 0x80)) {
+                break;
+            }
+            shift += 7;
+        }
+        return result >>> 0;
+    };
+    const readZigzagInt = () => {
+        const value = readVarint();
+        return (value >>> 1) ^ -(value & 1);
+    };
+    const readZigzagBigInt = () => {
+        let result = 0n;
+        let shift = 0n;
+        while (pos < buf.length) {
+            const byte = BigInt(buf[pos++]);
+            result |= (byte & 0x7fn) << shift;
+            if (!(byte & 0x80n)) {
+                break;
+            }
+            shift += 7n;
+        }
+        return (result >> 1n) ^ -(result & 1n);
+    };
+    const readString = () => {
+        const length = readVarint();
+        if (length < 0 || pos + length > buf.length) {
+            throw new Error(`Invalid Length: len=${length} pos=${pos} buf=${buf.length} field=${lastFieldId} type=${lastType}`);
+        }
+        const slice = buf.subarray(pos, pos + length);
+        pos += length;
+        if (!textStrings) {
+            return Buffer.from(slice);
+        }
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(slice);
+        }
+        catch {
+            return Buffer.from(slice);
+        }
+    };
+    /**
+     * Read a TCompact LIST or SET payload.
+     *
+     * @param header - Collection header byte.
+     * @returns Parsed collection items.
+     */
+    function readCollection(header) {
+        const items = [];
+        let size = (header >> 4) & 0xf;
+        const elementType = header & 0xf;
+        if (size === 15) {
+            size = readVarint();
+        }
+        if (size < 0 || size > 100000) {
+            throw new Error(`Invalid Length: collection=${size} pos=${pos} field=${lastFieldId} type=${lastType}`);
+        }
+        for (let i = 0; i < size; i++) {
+            items.push(readValue(elementType));
+        }
+        return items;
+    }
+    /**
+     * Read a TCompact MAP payload.
+     *
+     * @returns Parsed key/value object.
+     */
+    function readMap() {
+        const size = readVarint();
+        if (!size) {
+            return {};
+        }
+        const header = readByte();
+        const keyType = (header >> 4) & 0xf;
+        const valueType = header & 0xf;
+        const map = {};
+        if (size < 0 || size > 100000) {
+            throw new Error(`Invalid Length: map=${size} pos=${pos} field=${lastFieldId} type=${lastType}`);
+        }
+        for (let i = 0; i < size; i++) {
+            const key = readValue(keyType);
+            map[Buffer.isBuffer(key) ? key.toString('utf-8') : String(key)] =
+                readValue(valueType);
+        }
+        return map;
+    }
+    /**
+     * Read one TCompact DOUBLE value.
+     *
+     * @returns Parsed floating-point value.
+     */
+    function readDouble() {
+        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        const value = view.getFloat64(pos, true);
+        pos += 8;
+        return value;
+    }
+    const compactTypeReaders = {
+        readNullValue: () => null,
+        readTrueValue: () => true,
+        readFalseValue: () => false,
+        readByteValue: () => readByte(),
+        readI16Value: () => readZigzagInt(),
+        readI32Value: () => readZigzagInt(),
+        readI64Value: () => readZigzagBigInt(),
+        readDoubleValue: () => readDouble(),
+        readStringValue: () => readString(),
+        readCollectionValue: () => readCollection(readByte()),
+        readMapValue: () => readMap(),
+        readStructValue: () => readStruct(),
+    };
+    /**
+     * Read one compact field value.
+     *
+     * @param compactType - Compact wire type.
+     * @returns Parsed field value.
+     */
+    function readValue(compactType) {
+        const definition = getCompactStructTypeDefinition(compactType);
+        if (!definition) {
+            throw new Error(`Unknown compact type ${compactType} at pos ${pos}`);
+        }
+        return compactTypeReaders[definition.handler]();
+    }
+    /**
+     * Read one TCompact struct body.
+     *
+     * @returns Parsed struct fields keyed by field ID.
+     */
+    function readStruct() {
+        const fields = {};
+        let localLastFieldId = 0;
+        while (pos < buf.length) {
+            const header = readByte();
+            if (!header) {
+                break;
+            }
+            const compactType = header & 0xf;
+            const delta = (header >> 4) & 0xf;
+            const fieldId = delta ? localLastFieldId + delta : readZigzagInt();
+            localLastFieldId = fieldId;
+            lastFieldId = fieldId;
+            lastType = compactType;
+            fields[fieldId] = readValue(compactType);
+        }
+        return fields;
+    }
+    return readStruct();
+}