@dcl/ecs 7.0.6-3830539086.commit-6152fbd → 7.0.6-3832097301.commit-4e46b20

package/dist/engine/component.js

@@ -1,4 +1,4 @@
-import { createByteBuffer } from '../serialization/ByteBuffer';
+import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
 import { deepReadonly } from './readonly';
 export function defineComponent(componentId, spec
 // meta: { syncFlags }
@@ -92,7 +92,7 @@ export function defineComponent(componentId, spec
             if (!component) {
                 throw new Error(`[toBinary] Component ${componentId} for ${entity} not found`);
             }
-            const writeBuffer = createByteBuffer();
+            const writeBuffer = new ReadWriteByteBuffer();
             spec.serialize(component, writeBuffer);
             return writeBuffer;
         },
@@ -101,7 +101,7 @@ export function defineComponent(componentId, spec
             if (!component) {
                 return null;
             }
-            const writeBuffer = createByteBuffer();
+            const writeBuffer = new ReadWriteByteBuffer();
             spec.serialize(component, writeBuffer);
             return writeBuffer;
         },

package/dist/serialization/ByteBuffer/index.d.ts

@@ -1,29 +1,3 @@
-/**
- * @param writing - writing option, see object specs.
- * @param reading - reading option, see object specs.
- * @param initialCapacity - Initial capacity of buffer to allocate, ignored if you use writing or reading options
- */
-export interface CreateByteBufferOptions {
-    /**
-     * @param buffer - a buffer already allocated to read from there.
-     * @param currentOffset - set the cursor where begins to read. Default 0
-     * @param length - delimite where the valid data ends. Default: buffer.length
-     */
-    reading?: {
-        buffer: Uint8Array;
-        length?: number;
-        currentOffset: number;
-    };
-    /**
-     * @param buffer - a buffer already allocated to write there.
-     * @param currentOffset - set the cursor to not start writing from the begin of it. Default 0
-     */
-    writing?: {
-        buffer: Uint8Array;
-        currentOffset?: number;
-    };
-    initialCapacity?: number;
-}
 /**
  * ByteBuffer is a wrapper of DataView which also adds a read and write offset.
  *  Also in a write operation it resizes the buffer is being used if it needs.
@@ -31,7 +5,73 @@ export interface CreateByteBufferOptions {
  * - Use read and write function to generate or consume data.
  * - Use set and get only if you are sure that you're doing.
  */
-export declare function createByteBuffer(options?: CreateByteBufferOptions): ByteBuffer;
+export declare class ReadWriteByteBuffer implements ByteBuffer {
+    #private;
+    _buffer: Uint8Array;
+    view: DataView;
+    woffset: number;
+    roffset: number;
+    /**
+     * @param buffer - The initial buffer, provide a buffer if you need to set "initial capacity"
+     * @param readingOffset - Set the cursor where begins to read. Default 0
+     * @param writingOffset - Set the cursor to not start writing from the begin of it. Defaults to the buffer size
+     */
+    constructor(buffer?: Uint8Array | undefined, readingOffset?: number | undefined, writingOffset?: number | undefined);
+    buffer(): Uint8Array;
+    bufferLength(): number;
+    resetBuffer(): void;
+    currentReadOffset(): number;
+    currentWriteOffset(): number;
+    incrementReadOffset(amount: number): number;
+    remainingBytes(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): bigint;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): bigint;
+    readBuffer(): Uint8Array;
+    readUtf8String(): string;
+    incrementWriteOffset(amount: number): number;
+    toBinary(): Uint8Array;
+    toCopiedBinary(): Uint8Array;
+    writeBuffer(value: Uint8Array, writeLength?: boolean): void;
+    writeUtf8String(value: string, writeLength?: boolean): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt64(value: bigint): void;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: bigint): void;
+    getFloat32(offset: number): number;
+    getFloat64(offset: number): number;
+    getInt8(offset: number): number;
+    getInt16(offset: number): number;
+    getInt32(offset: number): number;
+    getInt64(offset: number): bigint;
+    getUint8(offset: number): number;
+    getUint16(offset: number): number;
+    getUint32(offset: number): number;
+    getUint64(offset: number): bigint;
+    setFloat32(offset: number, value: number): void;
+    setFloat64(offset: number, value: number): void;
+    setInt8(offset: number, value: number): void;
+    setInt16(offset: number, value: number): void;
+    setInt32(offset: number, value: number): void;
+    setInt64(offset: number, value: bigint): void;
+    setUint8(offset: number, value: number): void;
+    setUint16(offset: number, value: number): void;
+    setUint32(offset: number, value: number): void;
+    setUint64(offset: number, value: bigint): void;
+}
 /**
  * @public
  */
@@ -89,10 +129,6 @@ export declare type ByteBuffer = {
      * @returns The offset when this reserving starts.
      */
     incrementWriteOffset(amount: number): number;
-    /**
-     * @returns The total number of bytes writen in the buffer.
-     */
-    size(): number;
     /**
      * Take care using this function, if you modify the data after, the
      * returned subarray will change too. If you'll modify the content of the

package/dist/serialization/ByteBuffer/index.js

@@ -1,3 +1,9 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ReadWriteByteBuffer_instances, _ReadWriteByteBuffer_woAdd, _ReadWriteByteBuffer_roAdd;
 import * as utf8 from '@protobufjs/utf8';
 /**
  * Take the max between currentSize and intendedSize and then plus 1024. Then,
@@ -18,240 +24,220 @@ const defaultInitialCapacity = 10240;
  * - Use read and write function to generate or consume data.
  * - Use set and get only if you are sure that you're doing.
  */
-export function createByteBuffer(options = {}) {
-    const initialROffset = options.reading?.currentOffset || 0;
-    let initialBuffer = null;
-    let initialWOffset = 0;
-    if (options.writing) {
-        initialBuffer = options.writing.buffer;
-        if (options.writing.currentOffset) {
-            initialWOffset = options.writing.currentOffset;
-        }
+export class ReadWriteByteBuffer {
+    /**
+     * @param buffer - The initial buffer, provide a buffer if you need to set "initial capacity"
+     * @param readingOffset - Set the cursor where begins to read. Default 0
+     * @param writingOffset - Set the cursor to not start writing from the begin of it. Defaults to the buffer size
+     */
+    constructor(buffer, readingOffset, writingOffset) {
+        _ReadWriteByteBuffer_instances.add(this);
+        this._buffer = buffer || new Uint8Array(defaultInitialCapacity);
+        this.view = new DataView(this._buffer.buffer, this._buffer.byteOffset);
+        this.woffset = writingOffset ?? (buffer ? this._buffer.length : null) ?? 0;
+        this.roffset = readingOffset ?? 0;
     }
-    else if (options.reading) {
-        initialBuffer = options.reading.buffer;
-        initialWOffset = options.reading.length || options.reading.buffer.length;
+    buffer() {
+        return this._buffer;
     }
-    else {
-        initialBuffer = new Uint8Array(options.initialCapacity || defaultInitialCapacity);
+    bufferLength() {
+        return this._buffer.length;
     }
-    let buffer = initialBuffer;
-    let view = new DataView(buffer.buffer, buffer.byteOffset);
-    let woffset = initialWOffset;
-    let roffset = initialROffset;
-    /**
-     * Increement the write offset and resize the buffer if it needs.
-     */
-    const woAdd = (amount) => {
-        if (woffset + amount > buffer.byteLength) {
-            const newsize = getNextSize(buffer.byteLength, woffset + amount);
-            const newBuffer = new Uint8Array(newsize);
-            newBuffer.set(buffer);
-            buffer = newBuffer;
-            view = new DataView(buffer.buffer);
-        }
-        woffset += amount;
-        return woffset - amount;
-    };
-    /**
-     * Increment the read offset and throw an error if it's trying to read
-     *  outside the bounds.
-     */
-    const roAdd = (amount) => {
-        if (roffset + amount > woffset) {
-            throw new Error('Outside of the bounds of writen data.');
+    resetBuffer() {
+        this.roffset = 0;
+        this.woffset = 0;
+    }
+    currentReadOffset() {
+        return this.roffset;
+    }
+    currentWriteOffset() {
+        return this.woffset;
+    }
+    incrementReadOffset(amount) {
+        return __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, amount);
+    }
+    remainingBytes() {
+        return this.woffset - this.roffset;
+    }
+    readFloat32() {
+        return this.view.getFloat32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4));
+    }
+    readFloat64() {
+        return this.view.getFloat64(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 8));
+    }
+    readInt8() {
+        return this.view.getInt8(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 1));
+    }
+    readInt16() {
+        return this.view.getInt16(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 2));
+    }
+    readInt32() {
+        return this.view.getInt32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4));
+    }
+    readInt64() {
+        return this.view.getBigInt64(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 8));
+    }
+    readUint8() {
+        return this.view.getUint8(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 1));
+    }
+    readUint16() {
+        return this.view.getUint16(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 2));
+    }
+    readUint32() {
+        return this.view.getUint32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4));
+    }
+    readUint64() {
+        return this.view.getBigUint64(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 8));
+    }
+    readBuffer() {
+        const length = this.view.getUint32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4));
+        return this._buffer.subarray(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, length), __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 0));
+    }
+    readUtf8String() {
+        const length = this.view.getUint32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4));
+        return utf8.read(this._buffer, __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, length), __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 0));
+    }
+    incrementWriteOffset(amount) {
+        return __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, amount);
+    }
+    toBinary() {
+        return this._buffer.subarray(0, this.woffset);
+    }
+    toCopiedBinary() {
+        return new Uint8Array(this.toBinary());
+    }
+    writeBuffer(value, writeLength = true) {
+        if (writeLength) {
+            this.writeUint32(value.byteLength);
         }
-        roffset += amount;
-        return roffset - amount;
-    };
-    return {
-        buffer() {
-            return buffer;
-        },
-        bufferLength() {
-            return buffer.length;
-        },
-        resetBuffer() {
-            roffset = 0;
-            woffset = 0;
-        },
-        currentReadOffset() {
-            return roffset;
-        },
-        currentWriteOffset() {
-            return woffset;
-        },
-        incrementReadOffset(amount) {
-            return roAdd(amount);
-        },
-        remainingBytes() {
-            return woffset - roffset;
-        },
-        readFloat32() {
-            return view.getFloat32(roAdd(4));
-        },
-        readFloat64() {
-            return view.getFloat64(roAdd(8));
-        },
-        readInt8() {
-            return view.getInt8(roAdd(1));
-        },
-        readInt16() {
-            return view.getInt16(roAdd(2));
-        },
-        readInt32() {
-            return view.getInt32(roAdd(4));
-        },
-        readInt64() {
-            return view.getBigInt64(roAdd(8));
-        },
-        readUint8() {
-            return view.getUint8(roAdd(1));
-        },
-        readUint16() {
-            return view.getUint16(roAdd(2));
-        },
-        readUint32() {
-            return view.getUint32(roAdd(4));
-        },
-        readUint64() {
-            return view.getBigUint64(roAdd(8));
-        },
-        readBuffer() {
-            const length = view.getUint32(roAdd(4));
-            return buffer.subarray(roAdd(length), roAdd(0));
-        },
-        readUtf8String() {
-            const length = view.getUint32(roAdd(4));
-            return utf8.read(buffer, roAdd(length), roAdd(0));
-        },
-        incrementWriteOffset(amount) {
-            return woAdd(amount);
-        },
-        size() {
-            return woffset;
-        },
-        toBinary() {
-            return buffer.subarray(0, woffset);
-        },
-        toCopiedBinary() {
-            return new Uint8Array(this.toBinary());
-        },
-        writeBuffer(value, writeLength = true) {
-            if (writeLength) {
-                this.writeUint32(value.byteLength);
-            }
-            const o = woAdd(value.byteLength);
-            buffer.set(value, o);
-        },
-        writeUtf8String(value, writeLength = true) {
-            const byteLength = utf8.length(value);
-            if (writeLength) {
-                this.writeUint32(byteLength);
-            }
-            const o = woAdd(byteLength);
-            utf8.write(value, buffer, o);
-        },
-        writeFloat32(value) {
-            const o = woAdd(4);
-            view.setFloat32(o, value);
-        },
-        writeFloat64(value) {
-            const o = woAdd(8);
-            view.setFloat64(o, value);
-        },
-        writeInt8(value) {
-            const o = woAdd(1);
-            view.setInt8(o, value);
-        },
-        writeInt16(value) {
-            const o = woAdd(2);
-            view.setInt16(o, value);
-        },
-        writeInt32(value) {
-            const o = woAdd(4);
-            view.setInt32(o, value);
-        },
-        writeInt64(value) {
-            const o = woAdd(8);
-            view.setBigInt64(o, value);
-        },
-        writeUint8(value) {
-            const o = woAdd(1);
-            view.setUint8(o, value);
-        },
-        writeUint16(value) {
-            const o = woAdd(2);
-            view.setUint16(o, value);
-        },
-        writeUint32(value) {
-            const o = woAdd(4);
-            view.setUint32(o, value);
-        },
-        writeUint64(value) {
-            const o = woAdd(8);
-            view.setBigUint64(o, value);
-        },
-        // Dataview Proxy
-        getFloat32(offset) {
-            return view.getFloat32(offset);
-        },
-        getFloat64(offset) {
-            return view.getFloat64(offset);
-        },
-        getInt8(offset) {
-            return view.getInt8(offset);
-        },
-        getInt16(offset) {
-            return view.getInt16(offset);
-        },
-        getInt32(offset) {
-            return view.getInt32(offset);
-        },
-        getInt64(offset) {
-            return view.getBigInt64(offset);
-        },
-        getUint8(offset) {
-            return view.getUint8(offset);
-        },
-        getUint16(offset) {
-            return view.getUint16(offset);
-        },
-        getUint32(offset) {
-            return view.getUint32(offset);
-        },
-        getUint64(offset) {
-            return view.getBigUint64(offset);
-        },
-        setFloat32(offset, value) {
-            view.setFloat32(offset, value);
-        },
-        setFloat64(offset, value) {
-            view.setFloat64(offset, value);
-        },
-        setInt8(offset, value) {
-            view.setInt8(offset, value);
-        },
-        setInt16(offset, value) {
-            view.setInt16(offset, value);
-        },
-        setInt32(offset, value) {
-            view.setInt32(offset, value);
-        },
-        setInt64(offset, value) {
-            view.setBigInt64(offset, value);
-        },
-        setUint8(offset, value) {
-            view.setUint8(offset, value);
-        },
-        setUint16(offset, value) {
-            view.setUint16(offset, value);
-        },
-        setUint32(offset, value) {
-            view.setUint32(offset, value);
-        },
-        setUint64(offset, value) {
-            view.setBigUint64(offset, value);
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, value.byteLength);
+        this._buffer.set(value, o);
+    }
+    writeUtf8String(value, writeLength = true) {
+        const byteLength = utf8.length(value);
+        if (writeLength) {
+            this.writeUint32(byteLength);
         }
-    };
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, byteLength);
+        utf8.write(value, this._buffer, o);
+    }
+    writeFloat32(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 4);
+        this.view.setFloat32(o, value);
+    }
+    writeFloat64(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 8);
+        this.view.setFloat64(o, value);
+    }
+    writeInt8(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 1);
+        this.view.setInt8(o, value);
+    }
+    writeInt16(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 2);
+        this.view.setInt16(o, value);
+    }
+    writeInt32(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 4);
+        this.view.setInt32(o, value);
+    }
+    writeInt64(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 8);
+        this.view.setBigInt64(o, value);
+    }
+    writeUint8(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 1);
+        this.view.setUint8(o, value);
+    }
+    writeUint16(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 2);
+        this.view.setUint16(o, value);
+    }
+    writeUint32(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 4);
+        this.view.setUint32(o, value);
+    }
+    writeUint64(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 8);
+        this.view.setBigUint64(o, value);
+    }
+    // DataView Proxy
+    getFloat32(offset) {
+        return this.view.getFloat32(offset);
+    }
+    getFloat64(offset) {
+        return this.view.getFloat64(offset);
+    }
+    getInt8(offset) {
+        return this.view.getInt8(offset);
+    }
+    getInt16(offset) {
+        return this.view.getInt16(offset);
+    }
+    getInt32(offset) {
+        return this.view.getInt32(offset);
+    }
+    getInt64(offset) {
+        return this.view.getBigInt64(offset);
+    }
+    getUint8(offset) {
+        return this.view.getUint8(offset);
+    }
+    getUint16(offset) {
+        return this.view.getUint16(offset);
+    }
+    getUint32(offset) {
+        return this.view.getUint32(offset);
+    }
+    getUint64(offset) {
+        return this.view.getBigUint64(offset);
+    }
+    setFloat32(offset, value) {
+        this.view.setFloat32(offset, value);
+    }
+    setFloat64(offset, value) {
+        this.view.setFloat64(offset, value);
+    }
+    setInt8(offset, value) {
+        this.view.setInt8(offset, value);
+    }
+    setInt16(offset, value) {
+        this.view.setInt16(offset, value);
+    }
+    setInt32(offset, value) {
+        this.view.setInt32(offset, value);
+    }
+    setInt64(offset, value) {
+        this.view.setBigInt64(offset, value);
+    }
+    setUint8(offset, value) {
+        this.view.setUint8(offset, value);
+    }
+    setUint16(offset, value) {
+        this.view.setUint16(offset, value);
+    }
+    setUint32(offset, value) {
+        this.view.setUint32(offset, value);
+    }
+    setUint64(offset, value) {
+        this.view.setBigUint64(offset, value);
+    }
 }
+_ReadWriteByteBuffer_instances = new WeakSet(), _ReadWriteByteBuffer_woAdd = function _ReadWriteByteBuffer_woAdd(amount) {
+    if (this.woffset + amount > this._buffer.byteLength) {
+        const newsize = getNextSize(this._buffer.byteLength, this.woffset + amount);
+        const newBuffer = new Uint8Array(newsize);
+        newBuffer.set(this._buffer);
+        const oldOffset = this._buffer.byteOffset;
+        this._buffer = newBuffer;
+        this.view = new DataView(this._buffer.buffer, oldOffset);
+    }
+    this.woffset += amount;
+    return this.woffset - amount;
+}, _ReadWriteByteBuffer_roAdd = function _ReadWriteByteBuffer_roAdd(amount) {
+    if (this.roffset + amount > this.woffset) {
+        throw new Error('Outside of the bounds of writen data.');
+    }
+    this.roffset += amount;
+    return this.roffset - amount;
+};

package/dist/serialization/crdt/putComponent.js

@@ -12,7 +12,7 @@ export var PutComponentOperation;
         const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + PutComponentOperation.MESSAGE_HEADER_LENGTH);
         // write body
         componentDefinition.writeToByteBuffer(entity, buf);
-        const messageLength = buf.size() - startMessageOffset;
+        const messageLength = buf.currentWriteOffset() - startMessageOffset;
         // Write CrdtMessage header
         buf.setUint32(startMessageOffset, messageLength);
         buf.setUint32(startMessageOffset + 4, CrdtMessageType.PUT_COMPONENT);

package/dist/systems/crdt/index.js

@@ -1,7 +1,7 @@
 import { crdtProtocol } from '@dcl/crdt';
 import { CRDTMessageType, ProcessMessageResultType } from '@dcl/crdt/dist/types';
 import { EntityState, EntityUtils } from '../../engine/entity';
-import { createByteBuffer } from '../../serialization/ByteBuffer';
+import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
 import CrdtMessageProtocol from '../../serialization/crdt';
 import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
 import { DeleteEntity } from '../../serialization/crdt/deleteEntity';
@@ -32,9 +32,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
          * @param chunkMessage A chunk of binary messages
          */
         return function parseChunkMessage(chunkMessage) {
-            const buffer = createByteBuffer({
-                reading: { buffer: chunkMessage, currentOffset: 0 }
-            });
+            const buffer = new ReadWriteByteBuffer(chunkMessage);
             let header;
             while ((header = CrdtMessageProtocol.getHeader(buffer))) {
                 const offset = buffer.currentReadOffset();
@@ -94,10 +92,9 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
      */
     async function receiveMessages() {
         const messagesToProcess = getMessages(receivedMessages);
-        const bufferForOutdated = createByteBuffer();
+        const bufferForOutdated = new ReadWriteByteBuffer();
         const entitiesShouldBeCleaned = [];
         for (const msg of messagesToProcess) {
-            // TODO: emit delete entity to el onCrdtMessage
             if (msg.type === CrdtMessageType.DELETE_ENTITY) {
                 crdtClient.processMessage({
                     type: CRDTMessageType.CRDTMT_DeleteEntity,
@@ -106,7 +103,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 entitiesShouldBeCleaned.push(msg.entityId);
             }
             else {
-                // TODO: emit pu/delete component to el onCrdtMessage
                 const crdtMessage = {
                     type: CRDTMessageType.CRDTMT_PutComponentData,
                     entityId: msg.entityId,
@@ -142,10 +138,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                             component.deleteFrom(msg.entityId, false);
                         }
                         else {
-                            const opts = {
-                                reading: { buffer: msg.data, currentOffset: 0 }
-                            };
-                            const data = createByteBuffer(opts);
+                            const data = new ReadWriteByteBuffer(msg.data);
                             component.upsertFromBinary(msg.entityId, data, false);
                         }
                         onProcessEntityComponentChange &&
@@ -184,7 +177,6 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 }
             }
         }
-        // TODO: emit delete entity to el onCrdtMessage
         for (const entity of entitiesShouldBeCleaned) {
             // If we tried to resend outdated message and the entity was deleted before, we avoid sending them.
             for (let i = outdatedMessages.length - 1; i >= 0; i--) {
@@ -240,7 +232,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
         // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
         const crdtMessages = getMessages(broadcastMessages);
         const outdatedMessagesBkp = getMessages(outdatedMessages);
-        const buffer = createByteBuffer();
+        const buffer = new ReadWriteByteBuffer();
         for (const [component, entities] of dirtyEntities) {
             for (const entity of entities) {
                 // Component will be always defined here since dirtyMap its an iterator of engine.componentsDefinition
@@ -289,7 +281,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             });
         }
         // Send CRDT messages to transports
-        const transportBuffer = createByteBuffer();
+        const transportBuffer = new ReadWriteByteBuffer();
         for (const index in transports) {
             const transportIndex = Number(index);
             const transport = transports[transportIndex];
@@ -314,7 +306,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                     transportBuffer.writeBuffer(message.messageBuffer, false);
                 }
             }
-            const message = transportBuffer.size()
+            const message = transportBuffer.currentWriteOffset()
                 ? transportBuffer.toBinary()
                 : new Uint8Array([]);
             await transport.send(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.6-3830539086.commit-6152fbd",
+  "version": "7.0.6-3832097301.commit-4e46b20",
   "description": "Decentraland ECS",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -27,7 +27,7 @@
     "ts-proto": "^1.112.0"
   },
   "dependencies": {
-    "@dcl/crdt": "7.0.6-3830539086.commit-6152fbd",
+    "@dcl/crdt": "7.0.6-3832097301.commit-4e46b20",
     "@dcl/js-runtime": "file:../js-runtime",
     "@dcl/protocol": "^1.0.0-3808528053.commit-d66d462"
   },
@@ -41,5 +41,5 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "6152fbdf7dfabf5e0d61ef713e75e670ed3d69b8"
+  "commit": "4e46b208355a0a0d340a899c44f98bebb94d0c8b"
 }