@dcl/ecs 7.0.6-3824930139.commit-9bd6c05 → 7.0.6-3832097301.commit-4e46b20

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/deleteComponent.d.ts

@@ -0,0 +1,11 @@
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import { DeleteComponentMessage } from './types';
+export declare namespace DeleteComponent {
+    const MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Write DeleteComponent message
+     */
+    function write(entity: Entity, componentId: number, timestamp: number, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): DeleteComponentMessage | null;
+}

package/dist/serialization/crdt/deleteComponent.js

@@ -0,0 +1,45 @@
+import CrdtMessageProtocol from '.';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+export var DeleteComponent;
+(function (DeleteComponent) {
+    // TODO: change timestamp to 32 bit and remove buffer length (-8 bytes)
+    DeleteComponent.MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Write DeleteComponent message
+     */
+    function write(entity, componentId, timestamp, buf) {
+        // reserve the beginning
+        const messageLength = CRDT_MESSAGE_HEADER_LENGTH + DeleteComponent.MESSAGE_HEADER_LENGTH;
+        const startMessageOffset = buf.incrementWriteOffset(messageLength);
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, CrdtMessageType.DELETE_COMPONENT);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        // TODO: change timestamp to 32bit (-4 bytes)
+        buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
+        // TODO: remove buffer length (-4 bytes)
+        buf.setUint32(startMessageOffset + 24, 0);
+    }
+    DeleteComponent.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== CrdtMessageType.DELETE_COMPONENT) {
+            throw new Error('DeleteComponentOperation tried to read another message type.');
+        }
+        const msg = {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readInt32(),
+            timestamp: Number(buf.readUint64())
+        };
+        // TODO: remove buffer length
+        buf.incrementReadOffset(4);
+        return msg;
+    }
+    DeleteComponent.read = read;
+})(DeleteComponent || (DeleteComponent = {}));

package/dist/serialization/crdt/deleteEntity.d.ts

@@ -0,0 +1,8 @@
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import { DeleteEntityMessage } from './types';
+export declare namespace DeleteEntity {
+    const MESSAGE_HEADER_LENGTH = 4;
+    function write(entity: Entity, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): DeleteEntityMessage | null;
+}

package/dist/serialization/crdt/deleteEntity.js

@@ -0,0 +1,28 @@
+import CrdtMessageProtocol from '.';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+export var DeleteEntity;
+(function (DeleteEntity) {
+    DeleteEntity.MESSAGE_HEADER_LENGTH = 4;
+    function write(entity, buf) {
+        // Write CrdtMessage header
+        buf.writeUint32(CRDT_MESSAGE_HEADER_LENGTH + 4);
+        buf.writeUint32(CrdtMessageType.DELETE_ENTITY);
+        // body
+        buf.writeUint32(entity);
+    }
+    DeleteEntity.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== CrdtMessageType.DELETE_ENTITY) {
+            throw new Error('DeleteComponentOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32()
+        };
+    }
+    DeleteEntity.read = read;
+})(DeleteEntity || (DeleteEntity = {}));

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

@@ -0,0 +1,32 @@
+import { ByteBuffer } from '../ByteBuffer';
+import { CrdtMessageHeader } from './types';
+export * from './types';
+export * from './deleteComponent';
+export * from './putComponent';
+export * from './deleteEntity';
+export declare namespace CrdtMessageProtocol {
+    /**
+     * Validate if the message incoming is completed
+     * @param buf - ByteBuffer
+     */
+    function validate(buf: ByteBuffer): boolean;
+    /**
+     * Get the current header, consuming the bytes involved.
+     * @param buf - ByteBuffer
+     * @returns header or null if there is no validated message
+     */
+    function readHeader(buf: ByteBuffer): CrdtMessageHeader | null;
+    /**
+     * Get the current header, without consuming the bytes involved.
+     * @param buf - ByteBuffer
+     * @returns header or null if there is no validated message
+     */
+    function getHeader(buf: ByteBuffer): CrdtMessageHeader | null;
+    /**
+     * Consume the incoming message without processing it.
+     * @param buf - ByteBuffer
+     * @returns true in case of success or false if there is no valid message.
+     */
+    function consumeMessage(buf: ByteBuffer): boolean;
+}
+export default CrdtMessageProtocol;

package/dist/serialization/crdt/index.js

@@ -0,0 +1,70 @@
+import { CRDT_MESSAGE_HEADER_LENGTH } from './types';
+export * from './types';
+export * from './deleteComponent';
+export * from './putComponent';
+export * from './deleteEntity';
+export var CrdtMessageProtocol;
+(function (CrdtMessageProtocol) {
+    /**
+     * Validate if the message incoming is completed
+     * @param buf - ByteBuffer
+     */
+    function validate(buf) {
+        const rem = buf.remainingBytes();
+        if (rem < CRDT_MESSAGE_HEADER_LENGTH) {
+            return false;
+        }
+        const messageLength = buf.getUint32(buf.currentReadOffset());
+        if (rem < messageLength) {
+            return false;
+        }
+        return true;
+    }
+    CrdtMessageProtocol.validate = validate;
+    /**
+     * Get the current header, consuming the bytes involved.
+     * @param buf - ByteBuffer
+     * @returns header or null if there is no validated message
+     */
+    function readHeader(buf) {
+        if (!validate(buf)) {
+            return null;
+        }
+        return {
+            length: buf.readUint32(),
+            type: buf.readUint32()
+        };
+    }
+    CrdtMessageProtocol.readHeader = readHeader;
+    /**
+     * Get the current header, without consuming the bytes involved.
+     * @param buf - ByteBuffer
+     * @returns header or null if there is no validated message
+     */
+    function getHeader(buf) {
+        if (!validate(buf)) {
+            return null;
+        }
+        const currentOffset = buf.currentReadOffset();
+        return {
+            length: buf.getUint32(currentOffset),
+            type: buf.getUint32(currentOffset + 4)
+        };
+    }
+    CrdtMessageProtocol.getHeader = getHeader;
+    /**
+     * Consume the incoming message without processing it.
+     * @param buf - ByteBuffer
+     * @returns true in case of success or false if there is no valid message.
+     */
+    function consumeMessage(buf) {
+        const header = getHeader(buf);
+        if (!header) {
+            return false;
+        }
+        buf.incrementReadOffset(header.length);
+        return true;
+    }
+    CrdtMessageProtocol.consumeMessage = consumeMessage;
+})(CrdtMessageProtocol || (CrdtMessageProtocol = {}));
+export default CrdtMessageProtocol;

package/dist/serialization/crdt/message.d.ts

@@ -0,0 +1,3 @@
+import { ByteBuffer } from '../ByteBuffer';
+import { CrdtMessage } from './types';
+export declare function readMessage(buf: ByteBuffer): CrdtMessage | null;

package/dist/serialization/crdt/message.js

@@ -0,0 +1,17 @@
+import CrdtMessageProtocol, { DeleteComponent, DeleteEntity, PutComponentOperation } from '.';
+import { CrdtMessageType } from './types';
+export function readMessage(buf) {
+    const header = CrdtMessageProtocol.getHeader(buf);
+    if (!header)
+        return null;
+    if (header.type === CrdtMessageType.PUT_COMPONENT) {
+        return PutComponentOperation.read(buf);
+    }
+    else if (header.type === CrdtMessageType.DELETE_COMPONENT) {
+        return DeleteComponent.read(buf);
+    }
+    else if (header.type === CrdtMessageType.DELETE_ENTITY) {
+        return DeleteEntity.read(buf);
+    }
+    return null;
+}