@andrew_l/tl-pack 0.0.2 → 0.0.3

package/dist/BinaryReader.d.ts

@@ -1,16 +1,21 @@
 /// <reference types="node" resolution-mode="require"/>
+import { TLExtension } from './extension.js';
+export interface BinaryReaderOptions {
+    extensions?: TLExtension[];
+}
 export declare class BinaryReader {
     private target;
     private targetView;
     private _last?;
     private _dict;
+    private extensions;
     offset: number;
     length: number;
     /**
      * Small utility class to read binary data.
      * @param data {Buffer}
      */
-    constructor(data: Buffer | Uint8Array);
+    constructor(data: Buffer | Uint8Array, options?: BinaryReaderOptions);
     readByte(): number;
     readInt32(signed?: boolean): number;
     readInt16(signed?: boolean): number;
@@ -61,6 +66,7 @@ export declare class BinaryReader {
      * Reads a object.
      */
     readObject(): any;
+    private readCore;
     readDictionary(): string | null;
     readMap(checkConstructor?: boolean): Record<string, any>;
     decode(value: Buffer | Uint8Array): any;

package/dist/BinaryReader.js

@@ -5,19 +5,26 @@ export class BinaryReader {
     targetView;
     _last;
     _dict;
+    extensions;
     offset;
     length;
     /**
      * Small utility class to read binary data.
      * @param data {Buffer}
      */
-    constructor(data) {
+    constructor(data, options) {
         this.target = data;
         this.targetView = new DataView(data.buffer, 0, data.length);
         this._last = undefined;
         this._dict = new Map();
         this.offset = 0;
         this.length = data.length;
+        this.extensions = new Map();
+        if (options && options.extensions) {
+            options.extensions.forEach((ext) => {
+                this.extensions.set(ext.token, ext);
+            });
+        }
     }
     readByte() {
         this.assertRead(1);
@@ -41,7 +48,7 @@ export class BinaryReader {
             this._last = this.targetView.getInt16(this.offset, true);
         }
         else {
-            this._last = this.targetView.getUint16(this.offset);
+            this._last = this.targetView.getUint16(this.offset, true);
         }
         this.offset += 2;
         return this._last;
@@ -162,7 +169,20 @@ export class BinaryReader {
      * Reads a object.
      */
     readObject() {
+        const offset = this.offset;
         const constructorId = this.readByte();
+        const ext = this.extensions.get(constructorId);
+        let value;
+        if (ext) {
+            value = this.readObject();
+            value = ext.decode(value);
+        }
+        else {
+            value = this.readCore(constructorId);
+        }
+        return value;
+    }
+    readCore(constructorId) {
         switch (constructorId) {
             case CORE_TYPES.None:
                 return this.readObject();
@@ -203,22 +223,27 @@ export class BinaryReader {
     }
     readDictionary() {
         const constructorId = this.readByte();
+        let key = null;
         switch (constructorId) {
             case CORE_TYPES.DictIndex: {
                 const idx = this.readLength();
-                return this._dict.get(idx);
+                key = this._dict.get(idx);
+                break;
             }
             case CORE_TYPES.DictValue: {
-                const key = this.readString();
+                key = this.readString();
                 this._dict.set(this._dict.size + 1, key);
-                return key;
+                break;
             }
             case CORE_TYPES.None: {
-                return null;
+                key = null;
+                break;
+            }
+            default: {
+                this.seek(-1);
             }
         }
-        this.seek(-1);
-        return null;
+        return key;
     }
     readMap(checkConstructor = true) {
         if (checkConstructor && this.readByte() !== CORE_TYPES.Map) {

package/dist/BinaryWriter.d.ts

@@ -1,10 +1,15 @@
 /// <reference types="node" resolution-mode="require"/>
+import { TLExtension } from './extension.js';
+export interface BinaryWriterOptions {
+    extensions?: TLExtension[];
+}
 export declare class BinaryWriter {
     private target;
     private targetView;
     private dict;
+    private extensions;
     offset: number;
-    constructor();
+    constructor(options?: BinaryWriterOptions);
     allocate(size: number): void;
     makeRoom(end: number): void;
     get safeEnd(): number;
@@ -25,5 +30,7 @@ export declare class BinaryWriter {
     writeMap(object: Record<string, any>): void;
     wireDictionary(value: string): void;
     encode(value: any): Uint8Array | Buffer;
+    private _writeCustom;
     writeObject(value: any): void;
+    private writeCore;
 }

package/dist/BinaryWriter.js

@@ -21,11 +21,17 @@ export class BinaryWriter {
     target;
     targetView;
     dict;
+    extensions;
     offset;
-    constructor() {
-        this.target = Buffer.alloc(0);
+    constructor(options) {
         this.dict = new Map();
         this.offset = 0;
+        this.extensions = new Map();
+        if (options && options.extensions) {
+            options.extensions.forEach((ext) => {
+                this.extensions.set(ext.token, ext);
+            });
+        }
         this.target = byteArrayAllocate(8192);
         this.targetView = new DataView(this.target.buffer, 0, this.target.length);
     }
@@ -150,8 +156,6 @@ export class BinaryWriter {
             this.target[start++] = (bytes >> 16) % 256;
         }
         this.offset += bytes;
-        // this.target.set(bytes, this.offset);
-        // this.offset += bytes.length;
     }
     writeBytes(value) {
         const length = value.length;
@@ -177,11 +181,18 @@ export class BinaryWriter {
         const length = value.length;
         this.writeLength(length);
         for (let i = 0; i < length; i++) {
-            this.writeObject(value[i]);
+            if (value[i] === undefined) {
+                this.writeNull();
+            }
+            else {
+                this.writeObject(value[i]);
+            }
         }
     }
     writeMap(object) {
         for (const key in object) {
+            if (object[key] === undefined)
+                continue;
             this.wireDictionary(key);
             this.writeObject(object[key]);
         }
@@ -190,14 +201,12 @@ export class BinaryWriter {
     wireDictionary(value) {
         if (this.dict.has(value)) {
             const idx = this.dict.get(value);
-            this.writeByte(CORE_TYPES.DictIndex);
-            this.writeLength(idx);
+            this.writeCore(CORE_TYPES.DictIndex, idx);
         }
         else {
             const newIndex = this.dict.size + 1;
             this.dict.set(value, newIndex);
-            this.writeByte(CORE_TYPES.DictValue);
-            this.writeString(value);
+            this.writeCore(CORE_TYPES.DictValue, value);
         }
     }
     encode(value) {
@@ -207,18 +216,54 @@ export class BinaryWriter {
         this.offset = start;
         return this.target.subarray(start, end);
     }
+    _writeCustom(value) {
+        for (const ext of this.extensions.values()) {
+            const result = ext.encode(value);
+            if (result !== undefined) {
+                const constructorId = coreType(result);
+                if (constructorId === CORE_TYPES.None) {
+                    throw new TypeError(`Invalid encode extension = ${ext.token} type of ${value}`);
+                }
+                if (ext.token !== -1) {
+                    this.writeByte(ext.token);
+                }
+                this.writeCore(constructorId, result);
+                return true;
+            }
+        }
+        return false;
+    }
     writeObject(value) {
         if (value === undefined)
             return;
         const constructorId = coreType(value);
+        // console.log('write', {
+        // 	offset: this.offset,
+        // 	constructorId: CORE_TYPES[constructorId],
+        // 	value: String(value),
+        // });
         if (constructorId === CORE_TYPES.None) {
-            throw new TypeError(`Invalid core type of ${typeof value}`);
+            if (this._writeCustom(value)) {
+                return;
+            }
+            throw new TypeError(`Invalid core type of ${value}`);
         }
+        this.writeCore(constructorId, value);
+    }
+    writeCore(constructorId, value) {
         if (![CORE_TYPES.BoolFalse, CORE_TYPES.BoolTrue, CORE_TYPES.Null].includes(constructorId)) {
             this.writeByte(constructorId);
         }
         switch (constructorId) {
-            case CORE_TYPES.BoolFalse:
+            case CORE_TYPES.DictIndex: {
+                return this.writeLength(value);
+            }
+            case CORE_TYPES.DictValue: {
+                return this.writeString(value);
+            }
+            case CORE_TYPES.BoolFalse: {
+                return this.writeBool(value);
+            }
             case CORE_TYPES.BoolTrue: {
                 return this.writeBool(value);
             }

package/dist/extension.d.ts

@@ -0,0 +1,11 @@
+export type EncodeHandler = (value: any) => string | number | undefined;
+export type DecodeHandler = (value: string | number) => any;
+export interface TLExtension {
+    token: number;
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}
+export declare function createExtension(token: number, { encode, decode }: {
+    encode: EncodeHandler;
+    decode: DecodeHandler;
+}): TLExtension;

package/dist/extension.js

@@ -0,0 +1,10 @@
+export function createExtension(token, { encode, decode }) {
+    if (token !== -1 && (token > 254 || token < 0 || token << 0 !== token)) {
+        throw new TypeError('Token must be a 8 bit number');
+    }
+    return {
+        token,
+        encode,
+        decode,
+    };
+}

package/dist/helpers.js

@@ -95,11 +95,32 @@ export function coreType(value) {
             if (Array.isArray(value)) {
                 return CORE_TYPES.Vector;
             }
-            // @ts-ignore
-            if (toString.call(value) === '[object Object]') {
+            if (isPlainObject(value)) {
                 return CORE_TYPES.Map;
             }
         }
     }
     return CORE_TYPES.None;
 }
+/** @ts-ignore */
+const isObject = (val) => toString.call(val) === '[object Object]';
+function isPlainObject(value) {
+    let ctor, prot;
+    if (!isObject(value))
+        return false;
+    // If it has modified constructor
+    ctor = value.constructor;
+    if (ctor === undefined)
+        return true;
+    // If it has modified prototype
+    prot = ctor.prototype;
+    if (isObject(prot) === false)
+        return false;
+    // If constructor does not have an Object-specific method
+    // eslint-disable-next-line no-prototype-builtins
+    if (prot.hasOwnProperty('isPrototypeOf') === false) {
+        return false;
+    }
+    // Most likely a plain Object
+    return true;
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { BinaryWriter } from './BinaryWriter.js';
-export { BinaryReader } from './BinaryReader.js';
+export * from './BinaryWriter.js';
+export * from './BinaryReader.js';
 export * from './constants.js';
+export * from './extension.js';

package/dist/index.js

@@ -1,3 +1,4 @@
-export { BinaryWriter } from './BinaryWriter.js';
-export { BinaryReader } from './BinaryReader.js';
+export * from './BinaryWriter.js';
+export * from './BinaryReader.js';
 export * from './constants.js';
+export * from './extension.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@andrew_l/tl-pack",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "",
 	"type": "module",
 	"scripts": {