@dcl/ecs 7.3.31 → 7.3.32

package/dist/components/index.d.ts

@@ -8,6 +8,8 @@ import { TweenComponentDefinitionExtended } from './extended/Tween';
 import { LwwComponentGetter, GSetComponentGetter } from './generated/index.gen';
 import { NameType } from './manual/Name';
 import { ISyncComponentsType } from './manual/SyncComponents';
+import { INetowrkEntityType } from './manual/NetworkEntity';
+import { INetowrkParentType } from './manual/NetworkParent';
 import { TransformComponentExtended } from './manual/Transform';
 export * from './generated/index.gen';
 export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
@@ -25,3 +27,11 @@ export declare const Name: (engine: Pick<IEngine, 'defineComponent'>) => LastWri
  * @alpha
  */
 export declare const SyncComponents: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<ISyncComponentsType>;
+/**
+ * @alpha
+ */
+export declare const NetworkEntity: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkEntityType>;
+/**
+ * @alpha
+ */
+export declare const NetworkParent: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkParentType>;

package/dist/components/index.js

@@ -5,6 +5,8 @@ import { defineMeshRendererComponent } from './extended/MeshRenderer';
 import { defineTweenComponent } from './extended/Tween';
 import defineNameComponent from './manual/Name';
 import defineSyncComponent from './manual/SyncComponents';
+import defineNetworkEntity from './manual/NetworkEntity';
+import defineNetworkParent from './manual/NetworkParent';
 import { defineTransformComponent } from './manual/Transform';
 export * from './generated/index.gen';
 /* @__PURE__ */
@@ -29,3 +31,13 @@ export const Name = (engine) => defineNameComponent(engine);
  */
 /* @__PURE__ */
 export const SyncComponents = (engine) => defineSyncComponent(engine);
+/**
+ * @alpha
+ */
+/* @__PURE__ */
+export const NetworkEntity = (engine) => defineNetworkEntity(engine);
+/**
+ * @alpha
+ */
+/* @__PURE__ */
+export const NetworkParent = (engine) => defineNetworkParent(engine);

package/dist/components/manual/NetworkEntity.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from '../../engine';
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
+export interface INetowrkEntityType {
+    networkId: number;
+    entityId: Entity;
+}
+export type INetowrkEntity = LastWriteWinElementSetComponentDefinition<INetowrkEntityType>;
+declare function defineNetworkEntityComponent(engine: Pick<IEngine, 'defineComponent'>): import("../../engine").MapComponentDefinition<import("../..").MapResult<{
+    networkId: import("../../schemas").ISchema<number>;
+    entityId: import("../../schemas").ISchema<Entity>;
+}>>;
+export default defineNetworkEntityComponent;

package/dist/components/manual/NetworkEntity.js

@@ -0,0 +1,9 @@
+import { Schemas } from '../../schemas';
+function defineNetworkEntityComponent(engine) {
+    const EntityNetwork = engine.defineComponent('core-schema::Network-Entity', {
+        networkId: Schemas.Int64,
+        entityId: Schemas.Entity
+    });
+    return EntityNetwork;
+}
+export default defineNetworkEntityComponent;

package/dist/components/manual/NetworkParent.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from '../../engine';
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
+export interface INetowrkParentType {
+    networkId: number;
+    entityId: Entity;
+}
+export type INetowrkParent = LastWriteWinElementSetComponentDefinition<INetowrkParentType>;
+declare function defineNetworkParentComponent(engine: Pick<IEngine, 'defineComponent'>): import("../../engine").MapComponentDefinition<import("../..").MapResult<{
+    networkId: import("../../schemas").ISchema<number>;
+    entityId: import("../../schemas").ISchema<Entity>;
+}>>;
+export default defineNetworkParentComponent;

package/dist/components/manual/NetworkParent.js

@@ -0,0 +1,9 @@
+import { Schemas } from '../../schemas';
+function defineNetworkParentComponent(engine) {
+    const EntityNetwork = engine.defineComponent('core-schema::Network-Parent', {
+        networkId: Schemas.Int64,
+        entityId: Schemas.Entity
+    });
+    return EntityNetwork;
+}
+export default defineNetworkParentComponent;

package/dist/components/types.d.ts

@@ -6,3 +6,5 @@ export type { TweenHelper, TweenComponentDefinitionExtended } from './extended/T
 export type { TransformComponentExtended, TransformTypeWithOptionals } from './manual/Transform';
 export type { NameComponent, NameType } from './manual/Name';
 export type { ISyncComponents, ISyncComponentsType } from './manual/SyncComponents';
+export type { INetowrkEntity, INetowrkEntityType } from './manual/NetworkEntity';
+export type { INetowrkParent, INetowrkParentType } from './manual/NetworkParent';

package/dist/engine/index.js

@@ -15,7 +15,6 @@ function preEngine() {
     const entityContainer = EntityContainer();
     const componentsDefinition = new Map();
     const systems = SystemContainer();
-    let networkManager;
     let sealed = false;
     function addSystem(fn, priority = SYSTEMS_REGULAR_PRIORITY, name) {
         systems.add(fn, priority, name);
@@ -23,30 +22,22 @@ function preEngine() {
     function removeSystem(selector) {
         return systems.remove(selector);
     }
-    function getNetworkManager() {
-        if (!networkManager)
-            throw new Error('Network manager not initialized. Start CRDT Server');
-        return networkManager;
-    }
-    function addNetworkManager(reservedLocalEntities, range) {
-        entityContainer.setNetworkEntitiesRange(reservedLocalEntities, range);
-        networkManager = {
-            addEntity: () => entityContainer.generateEntity(true)
-        };
-        return networkManager;
-    }
     function addEntity() {
         const entity = entityContainer.generateEntity();
         return entity;
     }
     function removeEntity(entity) {
         for (const [, component] of componentsDefinition) {
+            // TODO: hack for the moment. It should be enough to delete the entity, but the renderer is not cleaning the components.
+            // So we still need the NetworkEntity to forward this message to the SyncTransport.
+            if (component.componentName === 'core-schema::Network-Entity')
+                continue;
             component.entityDeleted(entity, true);
         }
         return entityContainer.removeEntity(entity);
     }
     function removeEntityWithChildren(entity) {
-        return removeEntityWithChildrenEngine({ removeEntity, defineComponentFromSchema, getEntitiesWith }, entity);
+        return removeEntityWithChildrenEngine({ removeEntity, defineComponentFromSchema, getEntitiesWith, defineComponent }, entity);
     }
     function registerComponentDefinition(componentName, component) {
         /* istanbul ignore next */
@@ -123,7 +114,7 @@ function preEngine() {
         const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : componentNumberFromName(componentIdOrName);
         const component = componentsDefinition.get(componentId);
         if (!component) {
-            throw new Error(`Component ${componentId} not found. You need to declare the components at the beginnig of the engine declaration`);
+            throw new Error(`Component ${componentIdOrName} not found. You need to declare the components at the beginnig of the engine declaration`);
         }
         return component;
     }
@@ -197,9 +188,7 @@ function preEngine() {
         registerComponentDefinition,
         entityContainer,
         componentsIter,
-        seal,
-        addNetworkManager,
-        getNetworkManager
+        seal
     };
 }
 /**
@@ -243,8 +232,6 @@ export function Engine(options) {
         CameraEntity: 2,
         getEntityState: partialEngine.entityContainer.getEntityState,
         addTransport: crdtSystem.addTransport,
-        entityContainer: partialEngine.entityContainer,
-        addNetworkManager: partialEngine.addNetworkManager,
-        getNetworkManager: partialEngine.getNetworkManager
+        entityContainer: partialEngine.entityContainer
     };
 }

package/dist/engine/lww-element-set-component-definition.js

@@ -81,7 +81,10 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
     }
     return (msg) => {
         /* istanbul ignore next */
-        if (msg.type !== CrdtMessageType.PUT_COMPONENT && msg.type !== CrdtMessageType.DELETE_COMPONENT)
+        if (msg.type !== CrdtMessageType.PUT_COMPONENT &&
+            msg.type !== CrdtMessageType.PUT_COMPONENT_NETWORK &&
+            msg.type !== CrdtMessageType.DELETE_COMPONENT &&
+            msg.type !== CrdtMessageType.DELETE_COMPONENT_NETWORK)
             /* istanbul ignore next */
             return [null, data.get(msg.entityId)];
         const action = crdtRuleForCurrentState(msg);
@@ -90,7 +93,7 @@ export function createUpdateLwwFromCrdt(componentId, timestamps, schema, data) {
             case ProcessMessageResultType.StateUpdatedData:
             case ProcessMessageResultType.StateUpdatedTimestamp: {
                 timestamps.set(entity, msg.timestamp);
-                if (msg.type === CrdtMessageType.PUT_COMPONENT) {
+                if (msg.type === CrdtMessageType.PUT_COMPONENT || msg.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
                     const buf = new ReadWriteByteBuffer(msg.data);
                     data.set(entity, schema.deserialize(buf));
                 }

package/dist/engine/types.d.ts

@@ -227,16 +227,4 @@ export interface IEngine {
      * components that will be available to this engine and to run optimizations.
      */
     seal(): void;
-    /**
-     * @alpha
-     * Initialize network manager
-     */
-    addNetworkManager(reservedLocalEntities: number, range: [number, number]): {
-        addEntity: IEngine['addEntity'];
-    };
-    /**
-     * @alpha
-     * Get netowrk manager to create entities.
-     */
-    getNetworkManager(): ReturnType<IEngine['addNetworkManager']>;
 }

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export * from './systems/videoEvents';
 export * from './systems/async-task';
 export * from './engine/entity';
 export * from './components/types';
-import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended, ISyncComponents, TweenComponentDefinitionExtended } from './components/types';
+import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended, ISyncComponents, TweenComponentDefinitionExtended, INetowrkEntity, INetowrkParent } from './components/types';
 import { NameComponent } from './components/manual/Name';
 export declare const Transform: TransformComponentExtended;
 export declare const Animator: AnimatorComponentDefinitionExtended;
@@ -25,6 +25,16 @@ export declare const Tween: TweenComponentDefinitionExtended;
  * Can be modified in the future since it's still in research
  */
 export declare const SyncComponents: ISyncComponents;
+/**
+ * @alpha
+ * Tag a entity to be syncronized through comms
+ */
+export declare const NetworkEntity: INetowrkEntity;
+/**
+ * @alpha
+ * Tag a entity to be syncronized through comms
+ */
+export declare const NetworkParent: INetowrkParent;
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';
 export * from './serialization/crdt';

package/dist/index.js

@@ -30,6 +30,16 @@ export const Tween = /* @__PURE__*/ components.Tween(engine);
  * Can be modified in the future since it's still in research
  */
 export const SyncComponents = /* @__PURE__*/ components.SyncComponents(engine);
+/**
+ * @alpha
+ * Tag a entity to be syncronized through comms
+ */
+export const NetworkEntity = /* @__PURE__*/ components.NetworkEntity(engine);
+/**
+ * @alpha
+ * Tag a entity to be syncronized through comms
+ */
+export const NetworkParent = /* @__PURE__*/ components.NetworkParent(engine);
 // export components for global engine
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';

package/dist/runtime/helpers/tree.d.ts

@@ -29,4 +29,4 @@ export declare function getComponentEntityTree<T>(engine: Pick<IEngine, 'getEnti
  * @param firstEntity - the root entity of the tree
  * @public
  */
-export declare function removeEntityWithChildren(engine: Pick<IEngine, 'getEntitiesWith' | 'defineComponentFromSchema' | 'removeEntity'>, entity: Entity): void;
+export declare function removeEntityWithChildren(engine: Pick<IEngine, 'getEntitiesWith' | 'defineComponentFromSchema' | 'removeEntity' | 'defineComponent'>, entity: Entity): void;

package/dist/runtime/helpers/tree.js

@@ -35,6 +35,24 @@ export function getComponentEntityTree(engine, entity, component) {
     const entities = new Map(engine.getEntitiesWith(component));
     return genEntityTree(entity, entities);
 }
+// I swear by all the gods that this is being tested on test/sdk/network/sync-engines.spec.ts
+/* istanbul ignore next */
+function removeNetworkEntityChildrens(engine, parent) {
+    const NetworkParent = components.NetworkParent(engine);
+    const NetworkEntity = components.NetworkEntity(engine);
+    // Remove parent
+    engine.removeEntity(parent);
+    // Remove childs
+    const network = NetworkEntity.getOrNull(parent);
+    if (network) {
+        for (const [entity, parent] of engine.getEntitiesWith(NetworkParent)) {
+            if (parent.entityId === network.entityId && parent.networkId === network.networkId) {
+                removeNetworkEntityChildrens(engine, entity);
+            }
+        }
+    }
+    return;
+}
 /**
  * Remove all components of each entity in the tree made with Transform parenting
  * @param engine - the engine running the entities
@@ -43,7 +61,12 @@ export function getComponentEntityTree(engine, entity, component) {
  */
 export function removeEntityWithChildren(engine, entity) {
     const Transform = components.Transform(engine);
-    for (const _entity of getComponentEntityTree(engine, entity, Transform)) {
-        engine.removeEntity(_entity);
+    const NetworkEntity = components.NetworkEntity(engine);
+    /* istanbul ignore if */
+    if (NetworkEntity.has(entity)) {
+        return removeNetworkEntityChildrens(engine, entity);
+    }
+    for (const ent of getComponentEntityTree(engine, entity, Transform)) {
+        engine.removeEntity(ent);
     }
 }

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

@@ -2,5 +2,8 @@ export * from './deleteComponent';
 export * from './appendValue';
 export * from './deleteEntity';
 export * from './putComponent';
+export * from './network/putComponentNetwork';
+export * from './network/deleteComponentNetwork';
+export * from './network/deleteEntityNetwork';
 export * from './types';
 export * from './crdtMessageProtocol';

package/dist/serialization/crdt/index.js

@@ -2,5 +2,8 @@ export * from './deleteComponent';
 export * from './appendValue';
 export * from './deleteEntity';
 export * from './putComponent';
+export * from './network/putComponentNetwork';
+export * from './network/deleteComponentNetwork';
+export * from './network/deleteEntityNetwork';
 export * from './types';
 export * from './crdtMessageProtocol';

package/dist/serialization/crdt/message.js

@@ -4,6 +4,9 @@ import { PutComponentOperation } from './putComponent';
 import { DeleteComponent } from './deleteComponent';
 import { DeleteEntity } from './deleteEntity';
 import { AppendValueOperation } from './appendValue';
+import { PutNetworkComponentOperation } from './network/putComponentNetwork';
+import { DeleteComponentNetwork } from './network/deleteComponentNetwork';
+import { DeleteEntityNetwork } from './network/deleteEntityNetwork';
 export function readMessage(buf) {
     const header = CrdtMessageProtocol.getHeader(buf);
     if (!header)
@@ -11,14 +14,23 @@ export function readMessage(buf) {
     if (header.type === CrdtMessageType.PUT_COMPONENT) {
         return PutComponentOperation.read(buf);
     }
+    else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+        return PutNetworkComponentOperation.read(buf);
+    }
     else if (header.type === CrdtMessageType.DELETE_COMPONENT) {
         return DeleteComponent.read(buf);
     }
+    else if (header.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+        return DeleteComponentNetwork.read(buf);
+    }
     else if (header.type === CrdtMessageType.APPEND_VALUE) {
         return AppendValueOperation.read(buf);
     }
     else if (header.type === CrdtMessageType.DELETE_ENTITY) {
         return DeleteEntity.read(buf);
     }
+    else if (header.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+        return DeleteEntityNetwork.read(buf);
+    }
     return null;
 }

package/dist/serialization/crdt/network/deleteComponentNetwork.d.ts

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

package/dist/serialization/crdt/network/deleteComponentNetwork.js

@@ -0,0 +1,43 @@
+import { CrdtMessageProtocol } from '../crdtMessageProtocol';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from '../types';
+/**
+ * @public
+ */
+export var DeleteComponentNetwork;
+(function (DeleteComponentNetwork) {
+    DeleteComponentNetwork.MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Write DeleteComponent message
+     */
+    function write(entity, componentId, timestamp, networkId, buf) {
+        // reserve the beginning
+        const messageLength = CRDT_MESSAGE_HEADER_LENGTH + DeleteComponentNetwork.MESSAGE_HEADER_LENGTH;
+        const startMessageOffset = buf.incrementWriteOffset(messageLength);
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, CrdtMessageType.DELETE_COMPONENT_NETWORK);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+        buf.setUint32(startMessageOffset + 20, networkId);
+    }
+    DeleteComponentNetwork.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+            throw new Error('DeleteComponentOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32(),
+            networkId: buf.readUint32()
+        };
+    }
+    DeleteComponentNetwork.read = read;
+})(DeleteComponentNetwork || (DeleteComponentNetwork = {}));

package/dist/serialization/crdt/network/deleteEntityNetwork.d.ts

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

package/dist/serialization/crdt/network/deleteEntityNetwork.js

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

package/dist/serialization/crdt/network/putComponentNetwork.d.ts

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

package/dist/serialization/crdt/network/putComponentNetwork.js

@@ -0,0 +1,49 @@
+import { CrdtMessageProtocol } from '../crdtMessageProtocol';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from '../types';
+/**
+ * @public
+ */
+export var PutNetworkComponentOperation;
+(function (PutNetworkComponentOperation) {
+    PutNetworkComponentOperation.MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity, timestamp, componentId, networkId, data, buf) {
+        // reserve the beginning
+        const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + PutNetworkComponentOperation.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, CrdtMessageType.PUT_COMPONENT_NETWORK);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+        buf.setUint32(startMessageOffset + 20, networkId);
+        const dataLength = messageLength - PutNetworkComponentOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
+        buf.setUint32(startMessageOffset + 24, dataLength);
+    }
+    PutNetworkComponentOperation.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== CrdtMessageType.PUT_COMPONENT_NETWORK) {
+            throw new Error('PutComponentNetworkOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32(),
+            networkId: buf.readUint32(),
+            data: buf.readBuffer()
+        };
+    }
+    PutNetworkComponentOperation.read = read;
+})(PutNetworkComponentOperation || (PutNetworkComponentOperation = {}));

package/dist/serialization/crdt/network/utils.d.ts

@@ -0,0 +1,9 @@
+import { Entity } from '../../../engine';
+import { ReceiveMessage, TransformType } from '../../../runtime/types';
+import { ReceiveNetworkMessage } from '../../../systems/crdt/types';
+import { ByteBuffer } from '../../ByteBuffer';
+import { INetowrkEntityType } from '../../../components/types';
+export declare function isNetworkMessage(message: ReceiveMessage): message is ReceiveNetworkMessage;
+export declare function networkMessageToLocal(message: ReceiveNetworkMessage, localEntityId: Entity, buffer: ByteBuffer, destinationBuffer: ByteBuffer): void;
+export declare function localMessageToNetwork(message: ReceiveMessage, network: INetowrkEntityType, buffer: ByteBuffer, destinationBuffer: ByteBuffer): void;
+export declare function fixTransformParent(message: ReceiveMessage, transformValue?: TransformType, parent?: Entity): Uint8Array;

package/dist/serialization/crdt/network/utils.js

@@ -0,0 +1,62 @@
+import { ReadWriteByteBuffer } from '../../ByteBuffer';
+import { PutComponentOperation } from '../putComponent';
+import { CrdtMessageType } from '../types';
+import { DeleteComponent } from '../deleteComponent';
+import { DeleteEntity } from '../deleteEntity';
+import { PutNetworkComponentOperation } from './putComponentNetwork';
+import { DeleteComponentNetwork } from './deleteComponentNetwork';
+import { DeleteEntityNetwork } from './deleteEntityNetwork';
+import { TransformSchema } from '../../../components/manual/Transform';
+/* istanbul ignore next */
+export function isNetworkMessage(message) {
+    return [
+        CrdtMessageType.DELETE_COMPONENT_NETWORK,
+        CrdtMessageType.DELETE_ENTITY_NETWORK,
+        CrdtMessageType.PUT_COMPONENT_NETWORK
+    ].includes(message.type);
+}
+/* istanbul ignore next */
+export function networkMessageToLocal(message, localEntityId, buffer, destinationBuffer) {
+    const offset = buffer.currentWriteOffset();
+    if (message.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+        PutComponentOperation.write(localEntityId, message.timestamp, message.componentId, message.data, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+        DeleteComponent.write(localEntityId, message.componentId, message.timestamp, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+        DeleteEntity.write(localEntityId, buffer);
+    }
+    destinationBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+}
+/* istanbul ignore next */
+export function localMessageToNetwork(message, network, buffer, destinationBuffer) {
+    const offset = buffer.currentWriteOffset();
+    if (message.type === CrdtMessageType.PUT_COMPONENT) {
+        PutNetworkComponentOperation.write(network.entityId, message.timestamp, message.componentId, network.networkId, message.data, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_COMPONENT) {
+        DeleteComponentNetwork.write(network.entityId, message.componentId, message.timestamp, network.networkId, buffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_ENTITY) {
+        DeleteEntityNetwork.write(network.entityId, network.networkId, buffer);
+    }
+    destinationBuffer.writeBuffer(buffer.buffer().subarray(offset, buffer.currentWriteOffset()), false);
+}
+/* istanbul ignore next */
+export function fixTransformParent(message, transformValue, parent) {
+    let transform = transformValue;
+    const buffer = new ReadWriteByteBuffer();
+    if (!transform && 'data' in message) {
+        buffer.writeBuffer(message.data);
+        transform = TransformSchema.deserialize(buffer);
+        buffer.resetBuffer();
+    }
+    if (!transform)
+        throw new Error('Invalid parent transform');
+    // Generate new transform raw data with the parent
+    const newTransform = { ...transform, parent };
+    buffer.resetBuffer();
+    TransformSchema.serialize(newTransform, buffer);
+    return buffer.toBinary();
+}