@dcl/ecs 7.0.6-3823801200.commit-32470bd → 7.0.6-3830539086.commit-6152fbd

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

@@ -0,0 +1,53 @@
+import { Entity } from '../../engine/entity';
+export declare type Uint32 = number;
+export declare enum CrdtMessageType {
+    RESERVED = 0,
+    PUT_COMPONENT = 1,
+    DELETE_COMPONENT = 2,
+    DELETE_ENTITY = 3,
+    MAX_MESSAGE_TYPE = 4
+}
+/**
+ * Min length = 8 bytes
+ * All message length including
+ * @param length - Uint32 the length of all message (including the header)
+ * @param type - define the function which handles the data
+ */
+export declare type CrdtMessageHeader = {
+    length: Uint32;
+    type: Uint32;
+};
+export declare const CRDT_MESSAGE_HEADER_LENGTH = 8;
+/**
+ * Min. length = header (8 bytes) + 20 bytes = 28 bytes
+ *
+ * @param entity - Uint32 number of the entity
+ * @param componentId - Uint32 number of id
+ * @param timestamp - Uint64 Lamport timestamp
+ * @param data - Uint8[] data of component => length(4 bytes) + block of bytes[0..length-1]
+ */
+export declare type PutComponentMessageBody = {
+    type: CrdtMessageType.PUT_COMPONENT;
+    entityId: Entity;
+    componentId: number;
+    timestamp: number;
+    data: Uint8Array;
+};
+export declare type DeleteComponentMessageBody = {
+    type: CrdtMessageType.DELETE_COMPONENT;
+    entityId: Entity;
+    componentId: number;
+    timestamp: number;
+};
+/**
+ * @param entity - Uint32 number of the entity
+ */
+export declare type DeleteEntityMessageBody = {
+    type: CrdtMessageType.DELETE_ENTITY;
+    entityId: Entity;
+};
+export declare type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;
+export declare type DeleteComponentMessage = CrdtMessageHeader & DeleteComponentMessageBody;
+export declare type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;
+export declare type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage;
+export declare type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessage;

package/dist/serialization/crdt/types.js

@@ -0,0 +1,10 @@
+export var CrdtMessageType;
+(function (CrdtMessageType) {
+    CrdtMessageType[CrdtMessageType["RESERVED"] = 0] = "RESERVED";
+    // Component Operation
+    CrdtMessageType[CrdtMessageType["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
+    CrdtMessageType[CrdtMessageType["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
+    CrdtMessageType[CrdtMessageType["DELETE_ENTITY"] = 3] = "DELETE_ENTITY";
+    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
+})(CrdtMessageType || (CrdtMessageType = {}));
+export const CRDT_MESSAGE_HEADER_LENGTH = 8;

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

@@ -1,14 +1,14 @@
-import type { ComponentDefinition, IEngine } from '../../engine';
 import { Entity } from '../../engine/entity';
-import WireMessage from '../../serialization/wireMessage';
+import type { ComponentDefinition, IEngine } from '../../engine';
+import { CrdtMessageType } from '../../serialization/crdt/types';
 import { Transport } from './types';
 /**
  * @public
  */
-export declare type OnChangeFunction = (entity: Entity, component: ComponentDefinition<any>, operation: WireMessage.Enum) => void;
-export declare function crdtSceneSystem(engine: Pick<IEngine, 'getComponentOrNull' | 'getComponent' | 'componentsIter'>, onProcessEntityComponentChange: OnChangeFunction | null): {
+export declare type OnChangeFunction = (entity: Entity, operation: CrdtMessageType, component?: ComponentDefinition<any>) => void;
+export declare function crdtSceneSystem(engine: Pick<IEngine, 'getComponentOrNull' | 'getComponent' | 'entityContainer' | 'componentsIter'>, onProcessEntityComponentChange: OnChangeFunction | null): {
     getCrdt: () => import("@dcl/crdt").State<Uint8Array>;
-    sendMessages: (dirtyEntities: Map<ComponentDefinition<unknown>, Array<Entity>>) => Promise<void>;
+    sendMessages: (dirtyEntities: Map<ComponentDefinition<unknown>, Array<Entity>>, deletedEntities: Entity[]) => Promise<void>;
     receiveMessages: () => Promise<void>;
     addTransport: (transport: Transport) => void;
     updateState: () => Map<ComponentDefinition<unknown>, Entity[]>;

package/dist/systems/crdt/index.js

@@ -1,11 +1,19 @@
 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 { ComponentOperation as Message } from '../../serialization/crdt/componentOperation';
-import WireMessage from '../../serialization/wireMessage';
+import CrdtMessageProtocol from '../../serialization/crdt';
+import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
+import { DeleteEntity } from '../../serialization/crdt/deleteEntity';
+import { PutComponentOperation } from '../../serialization/crdt/putComponent';
+import { CrdtMessageType } from '../../serialization/crdt/types';
 export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
     // CRDT Client
-    const crdtClient = crdtProtocol();
+    const crdtClient = crdtProtocol({
+        toEntityId: EntityUtils.toEntityId,
+        fromEntityId: EntityUtils.fromEntityId
+    });
     // Messages that we received at transport.onMessage waiting to be processed
     const receivedMessages = [];
     // Messages already processed by the engine but that we need to broadcast to other transports.
@@ -27,21 +35,47 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             const buffer = createByteBuffer({
                 reading: { buffer: chunkMessage, currentOffset: 0 }
             });
-            while (WireMessage.validate(buffer)) {
+            let header;
+            while ((header = CrdtMessageProtocol.getHeader(buffer))) {
                 const offset = buffer.currentReadOffset();
-                const message = Message.read(buffer);
-                const { type, entity, componentId, data, timestamp } = message;
-                receivedMessages.push({
-                    type,
-                    entity,
-                    componentId,
-                    data,
-                    timestamp,
-                    transportId,
-                    messageBuffer: buffer
-                        .buffer()
-                        .subarray(offset, buffer.currentReadOffset())
-                });
+                if (header.type === CrdtMessageType.DELETE_COMPONENT) {
+                    const message = DeleteComponent.read(buffer);
+                    receivedMessages.push({
+                        ...header,
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer
+                            .buffer()
+                            .subarray(offset, buffer.currentReadOffset())
+                    });
+                }
+                else if (header.type === CrdtMessageType.PUT_COMPONENT) {
+                    const message = PutComponentOperation.read(buffer);
+                    receivedMessages.push({
+                        ...header,
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer
+                            .buffer()
+                            .subarray(offset, buffer.currentReadOffset())
+                    });
+                }
+                else if (header.type === CrdtMessageType.DELETE_ENTITY) {
+                    const message = DeleteEntity.read(buffer);
+                    receivedMessages.push({
+                        ...header,
+                        ...message,
+                        transportId,
+                        messageBuffer: buffer
+                            .buffer()
+                            .subarray(offset, buffer.currentReadOffset())
+                    });
+                    // Unknown message, we skip it
+                }
+                else {
+                    // consume the message
+                    buffer.incrementReadOffset(header.length);
+                }
             }
             // TODO: do something if buffler.len>0
         };
@@ -61,54 +95,109 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     async function receiveMessages() {
         const messagesToProcess = getMessages(receivedMessages);
         const bufferForOutdated = createByteBuffer();
-        for (const message of messagesToProcess) {
-            const { data, timestamp, componentId, entity, type } = message;
-            const crdtMessage = {
-                key1: entity,
-                key2: componentId,
-                data: data || null,
-                timestamp: timestamp
-            };
-            const component = engine.getComponentOrNull(componentId);
-            if (component?.isDirty(entity)) {
-                crdtClient.createEvent(entity, component._id, component.toBinaryOrNull(entity)?.toBinary() || null);
-            }
-            const current = crdtClient.processMessage(crdtMessage);
-            if (!component) {
-                continue;
-            }
-            // CRDT outdated message. Resend this message to the transport
-            // To do this we add this message to a queue that will be processed at the end of the update tick
-            if (crdtMessage !== current) {
-                const offset = bufferForOutdated.currentWriteOffset();
-                const type = WireMessage.getType(component, entity);
-                const ts = current.timestamp;
-                Message.write(type, entity, ts, component, bufferForOutdated);
-                outdatedMessages.push({
-                    ...message,
-                    timestamp: current.timestamp,
-                    messageBuffer: bufferForOutdated
-                        .buffer()
-                        .subarray(offset, bufferForOutdated.currentWriteOffset())
+        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,
+                    entityId: msg.entityId
                 });
+                entitiesShouldBeCleaned.push(msg.entityId);
             }
             else {
-                // Add message to transport queue to be processed by others transports
-                broadcastMessages.push(message);
-                // Process CRDT Message
-                if (type === WireMessage.Enum.DELETE_COMPONENT) {
-                    component.deleteFrom(entity, false);
+                // TODO: emit pu/delete component to el onCrdtMessage
+                const crdtMessage = {
+                    type: CRDTMessageType.CRDTMT_PutComponentData,
+                    entityId: msg.entityId,
+                    componentId: msg.componentId,
+                    data: msg.type === CrdtMessageType.PUT_COMPONENT ? msg.data : null,
+                    timestamp: msg.timestamp
+                };
+                const entityState = engine.entityContainer.getEntityState(msg.entityId);
+                // Skip updates from removed entityes
+                if (entityState === EntityState.Removed)
+                    continue;
+                // Entities with unknown entities should update its entity state
+                if (entityState === EntityState.Unknown) {
+                    engine.entityContainer.updateUsedEntity(msg.entityId);
                 }
-                else {
-                    const opts = {
-                        reading: { buffer: message.data, currentOffset: 0 }
-                    };
-                    const data = createByteBuffer(opts);
-                    component.upsertFromBinary(message.entity, data, false);
+                const component = engine.getComponentOrNull(msg.componentId);
+                // The state isn't updated because the dirty was set
+                //  out of the block of systems update between `receiveMessage` and `updateState`
+                if (component?.isDirty(msg.entityId)) {
+                    crdtClient.createComponentDataEvent(component._id, msg.entityId, component.toBinaryOrNull(msg.entityId)?.toBinary() || null);
+                }
+                const processResult = crdtClient.processMessage(crdtMessage);
+                if (!component) {
+                    continue;
+                }
+                switch (processResult) {
+                    case ProcessMessageResultType.StateUpdatedTimestamp:
+                    case ProcessMessageResultType.StateUpdatedData:
+                        // Add message to transport queue to be processed by others transports
+                        broadcastMessages.push(msg);
+                        // Process CRDT Message
+                        if (msg.type === CrdtMessageType.DELETE_COMPONENT) {
+                            component.deleteFrom(msg.entityId, false);
+                        }
+                        else {
+                            const opts = {
+                                reading: { buffer: msg.data, currentOffset: 0 }
+                            };
+                            const data = createByteBuffer(opts);
+                            component.upsertFromBinary(msg.entityId, data, false);
+                        }
+                        onProcessEntityComponentChange &&
+                            onProcessEntityComponentChange(msg.entityId, msg.type, component);
+                        break;
+                    // CRDT outdated message. Resend this message to the transport
+                    // To do this we add this message to a queue that will be processed at the end of the update tick
+                    case ProcessMessageResultType.StateOutdatedData:
+                    case ProcessMessageResultType.StateOutdatedTimestamp:
+                        const current = crdtClient
+                            .getState()
+                            .components.get(msg.componentId)
+                            ?.get(msg.entityId);
+                        if (current) {
+                            const offset = bufferForOutdated.currentWriteOffset();
+                            const ts = current.timestamp;
+                            if (component.has(msg.entityId)) {
+                                PutComponentOperation.write(msg.entityId, ts, component, bufferForOutdated);
+                            }
+                            else {
+                                DeleteComponent.write(msg.entityId, component._id, ts, bufferForOutdated);
+                            }
+                            outdatedMessages.push({
+                                ...msg,
+                                messageBuffer: bufferForOutdated
+                                    .buffer()
+                                    .subarray(offset, bufferForOutdated.currentWriteOffset())
+                            });
+                        }
+                        break;
+                    case ProcessMessageResultType.NoChanges:
+                    case ProcessMessageResultType.EntityDeleted:
+                    case ProcessMessageResultType.EntityWasDeleted:
+                    default:
+                        break;
+                }
+            }
+        }
+        // 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--) {
+                if (outdatedMessages[i].entityId === entity) {
+                    outdatedMessages.splice(i, 1);
                 }
-                onProcessEntityComponentChange &&
-                    onProcessEntityComponentChange(entity, component, type);
             }
+            for (const definition of engine.componentsIter()) {
+                definition.deleteFrom(entity, false);
+            }
+            engine.entityContainer.updateRemovedEntity(entity);
+            onProcessEntityComponentChange &&
+                onProcessEntityComponentChange(entity, CrdtMessageType.DELETE_ENTITY);
         }
     }
     /**
@@ -126,15 +215,20 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                     entitySet = [];
                     dirtyMap.set(component, entitySet);
                 }
-                entitySet.push(entity);
                 // TODO: reuse shared writer to prevent extra allocations of toBinary
                 const componentValue = component.toBinaryOrNull(entity)?.toBinary() ?? null;
                 // TODO: do not emit event if componentValue equals the value didn't change
-                crdtClient.createEvent(entity, component._id, componentValue);
-                onProcessEntityComponentChange &&
-                    onProcessEntityComponentChange(entity, component, componentValue === null
-                        ? WireMessage.Enum.DELETE_COMPONENT
-                        : WireMessage.Enum.PUT_COMPONENT);
+                // if update goes bad, the entity doesn't accept put anymore (it's added to deleted entities set)
+                if (crdtClient.createComponentDataEvent(component._id, entity, componentValue) === null) {
+                    component.deleteFrom(entity, false);
+                }
+                else {
+                    entitySet.push(entity);
+                    onProcessEntityComponentChange &&
+                        onProcessEntityComponentChange(entity, componentValue === null
+                            ? CrdtMessageType.DELETE_COMPONENT
+                            : CrdtMessageType.PUT_COMPONENT, component);
+                }
             }
         }
         return dirtyMap;
@@ -142,7 +236,7 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     /**
      * Iterates the dirty map and generates crdt messages to be send
      */
-    async function sendMessages(dirtyEntities) {
+    async function sendMessages(dirtyEntities, deletedEntities) {
         // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
         const crdtMessages = getMessages(broadcastMessages);
         const outdatedMessagesBkp = getMessages(outdatedMessages);
@@ -152,19 +246,26 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 // Component will be always defined here since dirtyMap its an iterator of engine.componentsDefinition
                 const { timestamp } = crdtClient
                     .getState()
-                    .get(entity)
-                    .get(component._id);
+                    .components.get(component._id)
+                    .get(entity);
                 const offset = buffer.currentWriteOffset();
-                const type = WireMessage.getType(component, entity);
+                const type = component.has(entity)
+                    ? CrdtMessageType.PUT_COMPONENT
+                    : CrdtMessageType.DELETE_COMPONENT;
                 const transportMessage = {
                     type,
+                    entityId: entity,
                     componentId: component._id,
-                    entity,
                     timestamp
                 };
                 // Avoid creating messages if there is no transport that will handle it
                 if (transports.some((t) => t.filter(transportMessage))) {
-                    Message.write(type, entity, timestamp, component, buffer);
+                    if (transportMessage.type === CrdtMessageType.PUT_COMPONENT) {
+                        PutComponentOperation.write(entity, timestamp, component, buffer);
+                    }
+                    else {
+                        DeleteComponent.write(entity, component._id, timestamp, buffer);
+                    }
                     crdtMessages.push({
                         ...transportMessage,
                         messageBuffer: buffer
@@ -174,6 +275,19 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
                 }
             }
         }
+        // After all updates, I execute the DeletedEntity messages
+        for (const entityId of deletedEntities) {
+            crdtClient.createDeleteEntityEvent(entityId);
+            const offset = buffer.currentWriteOffset();
+            DeleteEntity.write(entityId, buffer);
+            crdtMessages.push({
+                type: CrdtMessageType.DELETE_ENTITY,
+                entityId,
+                messageBuffer: buffer
+                    .buffer()
+                    .subarray(offset, buffer.currentWriteOffset())
+            });
+        }
         // Send CRDT messages to transports
         const transportBuffer = createByteBuffer();
         for (const index in transports) {
@@ -184,8 +298,11 @@ export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
             // So we can fix their crdt state
             for (const message of outdatedMessagesBkp) {
                 if (message.transportId === transportIndex &&
+                    // TODO: This is an optimization, the state should converge anyway, whatever the message is sent.
                     // Avoid sending multiple messages for the same entity-componentId
-                    !crdtMessages.find((m) => m.entity === message.entity &&
+                    !crdtMessages.find((m) => m.entityId === message.entityId &&
+                        // TODO: as any, with multiple type of messages, it should have many checks before the check for similar messages
+                        m.componentId &&
                         m.componentId === message.componentId)) {
                     transportBuffer.writeBuffer(message.messageBuffer, false);
                 }

package/dist/systems/crdt/types.d.ts

@@ -1,12 +1,6 @@
-import { Entity } from '../../engine/entity';
-import WireMessage from '../../serialization/wireMessage';
-export declare type ReceiveMessage = {
-    type: WireMessage.Enum;
-    entity: Entity;
-    componentId: number;
-    timestamp: number;
+import { CrdtMessageBody } from '../../serialization/crdt/types';
+export declare type ReceiveMessage = CrdtMessageBody & {
     transportId?: number;
-    data?: Uint8Array;
     messageBuffer: Uint8Array;
 };
 export declare type TransportMessage = Omit<ReceiveMessage, 'data'>;

package/dist/systems/events.js

@@ -1,4 +1,5 @@
 import * as components from '../components';
+import { EntityState } from '../engine/entity';
 import { checkNotThenable } from '../runtime/invariant';
 export function createPointerEventSystem(engine, inputSystem) {
     const PointerEvents = components.PointerEvents(engine);
@@ -53,7 +54,7 @@ export function createPointerEventSystem(engine, inputSystem) {
     // @internal
     engine.addSystem(function EventSystem() {
         for (const [entity, event] of eventsMap) {
-            if (!engine.entityExists(entity)) {
+            if (engine.getEntityState(entity) === EntityState.Removed) {
                 eventsMap.delete(entity);
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.6-3823801200.commit-32470bd",
+  "version": "7.0.6-3830539086.commit-6152fbd",
   "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-3823801200.commit-32470bd",
+    "@dcl/crdt": "7.0.6-3830539086.commit-6152fbd",
     "@dcl/js-runtime": "file:../js-runtime",
     "@dcl/protocol": "^1.0.0-3808528053.commit-d66d462"
   },
@@ -41,5 +41,5 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "32470bdb44a9d3c8663f432e0d3262a09c4201cf"
+  "commit": "6152fbdf7dfabf5e0d61ef713e75e670ed3d69b8"
 }

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

@@ -1,31 +0,0 @@
-import { ComponentDefinition } from '../../engine/component';
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import WireMessage from '../wireMessage';
-export declare namespace ComponentOperation {
-    /**
-     * @param entity - Uint32 number of the entity
-     * @param componentId - Uint32 number of id
-     * @param timestamp - Uint64 Lamport timestamp
-     * @param data - Uint8[] data of component
-     */
-    type IPutComponent = {
-        entity: Entity;
-        componentId: number;
-        timestamp: number;
-        data: Uint8Array;
-    };
-    type IDeleteComponent = {
-        entity: Entity;
-        componentId: number;
-        timestamp: number;
-        data?: undefined;
-    };
-    const MESSAGE_HEADER_LENGTH = 20;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(type: WireMessage.Enum, entity: Entity, timestamp: number, componentDefinition: ComponentDefinition<unknown>, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): (WireMessage.Header & (IPutComponent | IDeleteComponent)) | null;
-}

package/dist/serialization/crdt/componentOperation.js

@@ -1,47 +0,0 @@
-import WireMessage from '../wireMessage';
-export var ComponentOperation;
-(function (ComponentOperation) {
-    ComponentOperation.MESSAGE_HEADER_LENGTH = 20;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(type, entity, timestamp, componentDefinition, buf) {
-        // reserve the beginning
-        const startMessageOffset = buf.incrementWriteOffset(WireMessage.HEADER_LENGTH + ComponentOperation.MESSAGE_HEADER_LENGTH);
-        // write body
-        if (type === WireMessage.Enum.PUT_COMPONENT) {
-            componentDefinition.writeToByteBuffer(entity, buf);
-        }
-        const messageLength = buf.size() - startMessageOffset;
-        // Write WireMessage header
-        buf.setUint32(startMessageOffset, messageLength);
-        buf.setUint32(startMessageOffset + 4, type);
-        // Write ComponentOperation header
-        buf.setUint32(startMessageOffset + 8, entity);
-        buf.setUint32(startMessageOffset + 12, componentDefinition._id);
-        buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
-        buf.setUint32(startMessageOffset + 24, messageLength - ComponentOperation.MESSAGE_HEADER_LENGTH - WireMessage.HEADER_LENGTH);
-    }
-    ComponentOperation.write = write;
-    function read(buf) {
-        const header = WireMessage.readHeader(buf);
-        if (!header) {
-            return null;
-        }
-        const common = {
-            ...header,
-            entity: buf.readUint32(),
-            componentId: buf.readInt32(),
-            timestamp: Number(buf.readUint64())
-        };
-        if (header.type === WireMessage.Enum.DELETE_COMPONENT) {
-            return common;
-        }
-        return {
-            ...common,
-            data: buf.readBuffer()
-        };
-    }
-    ComponentOperation.read = read;
-})(ComponentOperation || (ComponentOperation = {}));

package/dist/serialization/wireMessage.d.ts

@@ -1,41 +0,0 @@
-/**
- * The wire message is the top-level message that can be packed
- *  inside it can contain a data with another structure or protocol
- *
- * Each wire message has three primitive property that it'll never change
- *   ---> length        uint32 (message size up to 4,294,967,295)
- *   ---> version       uint32 (for now just a number which is zero)
- *   ---> message type  uint32
- * The length indicates how many bytes are above self, the version in
- * combination with message type defines the set of handlers that will be
- * available to process the message
- *
- */
-import { ComponentDefinition, Entity } from '../engine';
-import { ByteBuffer } from './ByteBuffer';
-export declare namespace WireMessage {
-    type Uint32 = number;
-    enum Enum {
-        RESERVED = 0,
-        PUT_COMPONENT = 1,
-        DELETE_COMPONENT = 2,
-        MAX_MESSAGE_TYPE = 3
-    }
-    /**
-     * @param length - Uint32 the length of all message (including the header)
-     * @param type - define the function which handles the data
-     */
-    type Header = {
-        length: Uint32;
-        type: Uint32;
-    };
-    const HEADER_LENGTH = 8;
-    /**
-     * Validate if the message incoming is completed
-     * @param buf - ByteBuffer
-     */
-    function validate(buf: ByteBuffer): boolean;
-    function readHeader(buf: ByteBuffer): Header | null;
-    function getType(component: ComponentDefinition<unknown>, entity: Entity): Enum;
-}
-export default WireMessage;

package/dist/serialization/wireMessage.js

@@ -1,56 +0,0 @@
-/**
- * The wire message is the top-level message that can be packed
- *  inside it can contain a data with another structure or protocol
- *
- * Each wire message has three primitive property that it'll never change
- *   ---> length        uint32 (message size up to 4,294,967,295)
- *   ---> version       uint32 (for now just a number which is zero)
- *   ---> message type  uint32
- * The length indicates how many bytes are above self, the version in
- * combination with message type defines the set of handlers that will be
- * available to process the message
- *
- */
-export var WireMessage;
-(function (WireMessage) {
-    let Enum;
-    (function (Enum) {
-        Enum[Enum["RESERVED"] = 0] = "RESERVED";
-        // Component Operation
-        Enum[Enum["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
-        Enum[Enum["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
-        Enum[Enum["MAX_MESSAGE_TYPE"] = 3] = "MAX_MESSAGE_TYPE";
-    })(Enum = WireMessage.Enum || (WireMessage.Enum = {}));
-    WireMessage.HEADER_LENGTH = 8;
-    /**
-     * Validate if the message incoming is completed
-     * @param buf - ByteBuffer
-     */
-    function validate(buf) {
-        const rem = buf.remainingBytes();
-        if (rem < WireMessage.HEADER_LENGTH) {
-            return false;
-        }
-        const messageLength = buf.getUint32(buf.currentReadOffset());
-        if (rem < messageLength) {
-            return false;
-        }
-        return true;
-    }
-    WireMessage.validate = validate;
-    function readHeader(buf) {
-        if (!validate(buf)) {
-            return null;
-        }
-        return {
-            length: buf.readUint32(),
-            type: buf.readUint32()
-        };
-    }
-    WireMessage.readHeader = readHeader;
-    function getType(component, entity) {
-        return component.has(entity) ? Enum.PUT_COMPONENT : Enum.DELETE_COMPONENT;
-    }
-    WireMessage.getType = getType;
-})(WireMessage || (WireMessage = {}));
-export default WireMessage;