@dcl/ecs 7.1.12-4982829389.commit-f2f84bd → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/serialization/ByteBuffer/index.js

@@ -0,0 +1,272 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadWriteByteBuffer = void 0;
+const utf8 = __importStar(require("@protobufjs/utf8"));
+/**
+ * Take the max between currentSize and intendedSize and then plus 1024. Then,
+ *  find the next nearer multiple of 1024.
+ * @param currentSize - number
+ * @param intendedSize - number
+ * @returns the calculated number
+ */
+function getNextSize(currentSize, intendedSize) {
+    const minNewSize = Math.max(currentSize, intendedSize) + 1024;
+    return Math.ceil(minNewSize / 1024) * 1024;
+}
+const defaultInitialCapacity = 10240;
+/**
+ * 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.
+ *
+ * - Use read and write function to generate or consume data.
+ * - Use set and get only if you are sure that you're doing.
+ *
+ * It always passes littleEndian param as true
+ */
+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;
+    }
+    buffer() {
+        return this._buffer;
+    }
+    bufferLength() {
+        return this._buffer.length;
+    }
+    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), true); // littleEndian = true
+    }
+    readFloat64() {
+        return this.view.getFloat64(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 8), true); // littleEndian = true
+    }
+    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), true); // littleEndian = true
+    }
+    readInt32() {
+        return this.view.getInt32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4), true); // littleEndian = true
+    }
+    readInt64() {
+        return this.view.getBigInt64(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 8), true); // littleEndian = true
+    }
+    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), true); // littleEndian = true
+    }
+    readUint32() {
+        return this.view.getUint32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4), true); // littleEndian = true
+    }
+    readUint64() {
+        return this.view.getBigUint64(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 8), true); // littleEndian = true
+    }
+    readBuffer() {
+        const length = this.view.getUint32(__classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_roAdd).call(this, 4), true); // littleEndian = true
+        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), true); // littleEndian = true
+        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);
+        }
+        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, true); // littleEndian = true
+    }
+    writeFloat64(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 8);
+        this.view.setFloat64(o, value, true); // littleEndian = true
+    }
+    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, true); // littleEndian = true
+    }
+    writeInt32(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 4);
+        this.view.setInt32(o, value, true); // littleEndian = true
+    }
+    writeInt64(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 8);
+        this.view.setBigInt64(o, value, true); // littleEndian = true
+    }
+    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, true); // littleEndian = true
+    }
+    writeUint32(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 4);
+        this.view.setUint32(o, value, true); // littleEndian = true
+    }
+    writeUint64(value) {
+        const o = __classPrivateFieldGet(this, _ReadWriteByteBuffer_instances, "m", _ReadWriteByteBuffer_woAdd).call(this, 8);
+        this.view.setBigUint64(o, value, true); // littleEndian = true
+    }
+    // DataView Proxy
+    getFloat32(offset) {
+        return this.view.getFloat32(offset, true); // littleEndian = true
+    }
+    getFloat64(offset) {
+        return this.view.getFloat64(offset, true); // littleEndian = true
+    }
+    getInt8(offset) {
+        return this.view.getInt8(offset);
+    }
+    getInt16(offset) {
+        return this.view.getInt16(offset, true); // littleEndian = true
+    }
+    getInt32(offset) {
+        return this.view.getInt32(offset, true); // littleEndian = true
+    }
+    getInt64(offset) {
+        return this.view.getBigInt64(offset, true); // littleEndian = true
+    }
+    getUint8(offset) {
+        return this.view.getUint8(offset);
+    }
+    getUint16(offset) {
+        return this.view.getUint16(offset, true); // littleEndian = true
+    }
+    getUint32(offset) {
+        return this.view.getUint32(offset, true); // littleEndian = true >>> 0
+    }
+    getUint64(offset) {
+        return this.view.getBigUint64(offset, true); // littleEndian = true
+    }
+    setFloat32(offset, value) {
+        this.view.setFloat32(offset, value, true); // littleEndian = true
+    }
+    setFloat64(offset, value) {
+        this.view.setFloat64(offset, value, true); // littleEndian = true
+    }
+    setInt8(offset, value) {
+        this.view.setInt8(offset, value);
+    }
+    setInt16(offset, value) {
+        this.view.setInt16(offset, value, true); // littleEndian = true
+    }
+    setInt32(offset, value) {
+        this.view.setInt32(offset, value, true); // littleEndian = true
+    }
+    setInt64(offset, value) {
+        this.view.setBigInt64(offset, value, true); // littleEndian = true
+    }
+    setUint8(offset, value) {
+        this.view.setUint8(offset, value);
+    }
+    setUint16(offset, value) {
+        this.view.setUint16(offset, value, true); // littleEndian = true
+    }
+    setUint32(offset, value) {
+        this.view.setUint32(offset, value, true); // littleEndian = true
+    }
+    setUint64(offset, value) {
+        this.view.setBigUint64(offset, value, true); // littleEndian = true
+    }
+}
+exports.ReadWriteByteBuffer = ReadWriteByteBuffer;
+_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-cjs/serialization/crdt/appendValue.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import { AppendValueMessage } from './types';
+/**
+ * @public
+ */
+export declare namespace AppendValueOperation {
+    const MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): AppendValueMessage | null;
+}

package/dist-cjs/serialization/crdt/appendValue.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppendValueOperation = void 0;
+const crdtMessageProtocol_1 = require("./crdtMessageProtocol");
+const types_1 = require("./types");
+/**
+ * @public
+ */
+var AppendValueOperation;
+(function (AppendValueOperation) {
+    AppendValueOperation.MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity, timestamp, componentId, data, buf) {
+        // reserve the beginning
+        const startMessageOffset = buf.incrementWriteOffset(types_1.CRDT_MESSAGE_HEADER_LENGTH + AppendValueOperation.MESSAGE_HEADER_LENGTH);
+        // write body
+        buf.writeBuffer(data, false);
+        const messageLength = buf.currentWriteOffset() - startMessageOffset;
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, types_1.CrdtMessageType.APPEND_VALUE);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+        const newLocal = messageLength - AppendValueOperation.MESSAGE_HEADER_LENGTH - types_1.CRDT_MESSAGE_HEADER_LENGTH;
+        buf.setUint32(startMessageOffset + 20, newLocal);
+    }
+    AppendValueOperation.write = write;
+    function read(buf) {
+        const header = crdtMessageProtocol_1.CrdtMessageProtocol.readHeader(buf);
+        /* istanbul ignore if */
+        if (!header) {
+            return null;
+        }
+        /* istanbul ignore if */
+        if (header.type !== types_1.CrdtMessageType.APPEND_VALUE) {
+            throw new Error('AppendValueOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32(),
+            data: buf.readBuffer()
+        };
+    }
+    AppendValueOperation.read = read;
+})(AppendValueOperation = exports.AppendValueOperation || (exports.AppendValueOperation = {}));

package/dist-cjs/serialization/crdt/crdtMessageProtocol.d.ts

@@ -0,0 +1,30 @@
+import { ByteBuffer } from '../ByteBuffer';
+import { CrdtMessageHeader } from './types';
+/**
+ * @public
+ */
+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;
+}

package/dist-cjs/serialization/crdt/crdtMessageProtocol.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrdtMessageProtocol = void 0;
+const types_1 = require("./types");
+/**
+ * @public
+ */
+var CrdtMessageProtocol;
+(function (CrdtMessageProtocol) {
+    /**
+     * Validate if the message incoming is completed
+     * @param buf - ByteBuffer
+     */
+    function validate(buf) {
+        const rem = buf.remainingBytes();
+        if (rem < types_1.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 = exports.CrdtMessageProtocol || (exports.CrdtMessageProtocol = {}));

package/dist-cjs/serialization/crdt/deleteComponent.d.ts

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

package/dist-cjs/serialization/crdt/deleteComponent.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteComponent = void 0;
+const crdtMessageProtocol_1 = require("./crdtMessageProtocol");
+const types_1 = require("./types");
+/**
+ * @public
+ */
+var DeleteComponent;
+(function (DeleteComponent) {
+    DeleteComponent.MESSAGE_HEADER_LENGTH = 12;
+    /**
+     * Write DeleteComponent message
+     */
+    function write(entity, componentId, timestamp, buf) {
+        // reserve the beginning
+        const messageLength = types_1.CRDT_MESSAGE_HEADER_LENGTH + DeleteComponent.MESSAGE_HEADER_LENGTH;
+        const startMessageOffset = buf.incrementWriteOffset(messageLength);
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, types_1.CrdtMessageType.DELETE_COMPONENT);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+    }
+    DeleteComponent.write = write;
+    function read(buf) {
+        const header = crdtMessageProtocol_1.CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== types_1.CrdtMessageType.DELETE_COMPONENT) {
+            throw new Error('DeleteComponentOperation tried to read another message type.');
+        }
+        const msg = {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32()
+        };
+        return msg;
+    }
+    DeleteComponent.read = read;
+})(DeleteComponent = exports.DeleteComponent || (exports.DeleteComponent = {}));

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

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

package/dist-cjs/serialization/crdt/deleteEntity.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteEntity = void 0;
+const crdtMessageProtocol_1 = require("./crdtMessageProtocol");
+const types_1 = require("./types");
+/**
+ * @public
+ */
+var DeleteEntity;
+(function (DeleteEntity) {
+    DeleteEntity.MESSAGE_HEADER_LENGTH = 4;
+    function write(entity, buf) {
+        // Write CrdtMessage header
+        buf.writeUint32(types_1.CRDT_MESSAGE_HEADER_LENGTH + 4);
+        buf.writeUint32(types_1.CrdtMessageType.DELETE_ENTITY);
+        // body
+        buf.writeUint32(entity);
+    }
+    DeleteEntity.write = write;
+    function read(buf) {
+        const header = crdtMessageProtocol_1.CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== types_1.CrdtMessageType.DELETE_ENTITY) {
+            throw new Error('DeleteEntity tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32()
+        };
+    }
+    DeleteEntity.read = read;
+})(DeleteEntity = exports.DeleteEntity || (exports.DeleteEntity = {}));

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

@@ -0,0 +1,6 @@
+export * from './deleteComponent';
+export * from './appendValue';
+export * from './deleteEntity';
+export * from './putComponent';
+export * from './types';
+export * from './crdtMessageProtocol';

package/dist-cjs/serialization/crdt/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./deleteComponent"), exports);
+__exportStar(require("./appendValue"), exports);
+__exportStar(require("./deleteEntity"), exports);
+__exportStar(require("./putComponent"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./crdtMessageProtocol"), exports);

package/dist-cjs/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-cjs/serialization/crdt/message.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMessage = void 0;
+const crdtMessageProtocol_1 = require("./crdtMessageProtocol");
+const types_1 = require("./types");
+const putComponent_1 = require("./putComponent");
+const deleteComponent_1 = require("./deleteComponent");
+const deleteEntity_1 = require("./deleteEntity");
+const appendValue_1 = require("./appendValue");
+function readMessage(buf) {
+    const header = crdtMessageProtocol_1.CrdtMessageProtocol.getHeader(buf);
+    if (!header)
+        return null;
+    if (header.type === types_1.CrdtMessageType.PUT_COMPONENT) {
+        return putComponent_1.PutComponentOperation.read(buf);
+    }
+    else if (header.type === types_1.CrdtMessageType.DELETE_COMPONENT) {
+        return deleteComponent_1.DeleteComponent.read(buf);
+    }
+    else if (header.type === types_1.CrdtMessageType.APPEND_VALUE) {
+        return appendValue_1.AppendValueOperation.read(buf);
+    }
+    else if (header.type === types_1.CrdtMessageType.DELETE_ENTITY) {
+        return deleteEntity_1.DeleteEntity.read(buf);
+    }
+    return null;
+}
+exports.readMessage = readMessage;

package/dist-cjs/serialization/crdt/putComponent.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import { PutComponentMessage } from './types';
+/**
+ * @public
+ */
+export declare namespace PutComponentOperation {
+    const MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): PutComponentMessage | null;
+}