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

package/dist/engine/entity.d.ts

@@ -17,7 +17,7 @@ export declare const AMOUNT_VERSION_AVAILABLE: number;
  * Convertion from its compound numbers to entity:
  * entity = (entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)
  */
-export declare type Entity = uint32 & {
+export declare type Entity = number & {
     __entity_type: '';
 };
 /**
@@ -28,12 +28,41 @@ export declare const RESERVED_STATIC_ENTITIES = 512;
  * @public
  */
 export declare const MAX_ENTITY_NUMBER = 65535;
-export declare function EntityContainer(): {
+export declare namespace EntityUtils {
+    /**
+     * @returns [entityNumber, entityVersion]
+     */
+    function fromEntityId(entityId: Entity): [number, number];
+    /**
+     * @returns compound number from entityNumber and entityVerison
+     */
+    function toEntityId(entityNumber: number, entityVersion: number): Entity;
+}
+/**
+ * @public
+ */
+export declare enum EntityState {
+    Unknown = 0,
+    /**
+     * The entity was generated and added to the usedEntities set
+     */
+    UsedEntity = 1,
+    /**
+     * The entity was removed from current engine or remotely
+     */
+    Removed = 2,
+    /**
+     * The entity is reserved number.
+     */
+    Reserved = 3
+}
+export declare type EntityContainer = {
     generateEntity(): Entity;
     removeEntity(entity: Entity): boolean;
-    entityExists(entity: Entity): boolean;
+    getEntityState(entity: Entity): EntityState;
     getExistingEntities(): Set<Entity>;
-    entityVersion: (entity: Entity) => number;
-    entityNumber: (entity: Entity) => number;
-    entityId: (entityNumber: number, entityVersion: number) => Entity;
+    releaseRemovedEntities(): Entity[];
+    updateRemovedEntity(entity: Entity): boolean;
+    updateUsedEntity(entity: Entity): boolean;
 };
+export declare function EntityContainer(): EntityContainer;

package/dist/engine/entity.js

@@ -1,6 +1,8 @@
+import { createGSet } from '@dcl/crdt/dist/gset';
 export const MAX_U16 = 0xffff;
 export const MASK_UPPER_16_ON_32 = 0xffff0000;
 export const AMOUNT_VERSION_AVAILABLE = MAX_U16 + 1;
+// This type matches with @dcl/crdt entity type.
 /**
  * @public This first 512 entities are reserved by the renderer
  */
@@ -9,64 +11,151 @@ export const RESERVED_STATIC_ENTITIES = 512;
  * @public
  */
 export const MAX_ENTITY_NUMBER = MAX_U16;
-export function EntityContainer() {
-    let entityCounter = RESERVED_STATIC_ENTITIES;
-    const usedEntities = new Set();
-    const removedEntities = new Map();
-    function entityVersion(entity) {
-        return (((entity & MASK_UPPER_16_ON_32) >> 16) & MAX_U16) >>> 0;
-    }
-    function entityNumber(entity) {
-        return (entity & MAX_U16) >>> 0;
+export var EntityUtils;
+(function (EntityUtils) {
+    /**
+     * @returns [entityNumber, entityVersion]
+     */
+    function fromEntityId(entityId) {
+        return [
+            (entityId & MAX_U16) >>> 0,
+            (((entityId & MASK_UPPER_16_ON_32) >> 16) & MAX_U16) >>> 0
+        ];
     }
-    function entityId(entityNumber, entityVersion) {
+    EntityUtils.fromEntityId = fromEntityId;
+    /**
+     * @returns compound number from entityNumber and entityVerison
+     */
+    function toEntityId(entityNumber, entityVersion) {
         return (((entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)) >>>
             0);
     }
+    EntityUtils.toEntityId = toEntityId;
+})(EntityUtils || (EntityUtils = {}));
+/**
+ * @public
+ */
+export var EntityState;
+(function (EntityState) {
+    EntityState[EntityState["Unknown"] = 0] = "Unknown";
+    /**
+     * The entity was generated and added to the usedEntities set
+     */
+    EntityState[EntityState["UsedEntity"] = 1] = "UsedEntity";
+    /**
+     * The entity was removed from current engine or remotely
+     */
+    EntityState[EntityState["Removed"] = 2] = "Removed";
+    /**
+     * The entity is reserved number.
+     */
+    EntityState[EntityState["Reserved"] = 3] = "Reserved";
+})(EntityState || (EntityState = {}));
+export function EntityContainer() {
+    let entityCounter = RESERVED_STATIC_ENTITIES;
+    const usedEntities = new Set();
+    let toRemoveEntities = [];
+    const removedEntities = createGSet();
     function generateNewEntity() {
         if (entityCounter > MAX_ENTITY_NUMBER - 1) {
             throw new Error(`It fails trying to generate an entity out of range ${MAX_ENTITY_NUMBER}.`);
         }
-        const entity = entityCounter++;
+        const entityNumber = entityCounter++;
+        const entityVersion = removedEntities.getMap().has(entityNumber)
+            ? removedEntities.getMap().get(entityNumber) + 1
+            : 0;
+        const entity = EntityUtils.toEntityId(entityNumber, entityVersion);
         usedEntities.add(entity);
         return entity;
     }
     function generateEntity() {
+        // If all entities until `entityCounter` are being used, we need to generate another one
         if (usedEntities.size + RESERVED_STATIC_ENTITIES >= entityCounter) {
             return generateNewEntity();
         }
-        for (const [number, version] of removedEntities) {
+        for (const [number, version] of removedEntities.getMap()) {
             if (version < MAX_U16) {
-                const entity = entityId(number, version + 1);
-                usedEntities.add(entity);
-                removedEntities.delete(number);
-                return entity;
+                const entity = EntityUtils.toEntityId(number, version + 1);
+                // If the entity is not being used, we can re-use it
+                // If the entity was removed in this tick, we're not counting for the usedEntities, but we have it in the toRemoveEntityArray
+                if (!usedEntities.has(entity) && !toRemoveEntities.includes(entity)) {
+                    usedEntities.add(entity);
+                    return entity;
+                }
             }
         }
         return generateNewEntity();
     }
     function removeEntity(entity) {
-        const deleted = usedEntities.delete(entity);
-        if (deleted) {
-            removedEntities.set(entityNumber(entity), entityVersion(entity));
+        if (entity < RESERVED_STATIC_ENTITIES)
+            return false;
+        if (usedEntities.has(entity)) {
+            usedEntities.delete(entity);
+            toRemoveEntities.push(entity);
+        }
+        else {
+            updateRemovedEntity(entity);
         }
-        return deleted;
+        return true;
+    }
+    function releaseRemovedEntities() {
+        const arr = toRemoveEntities;
+        toRemoveEntities = [];
+        for (const entity of arr) {
+            const [n, v] = EntityUtils.fromEntityId(entity);
+            removedEntities.addTo(n, v);
+        }
+        return arr;
+    }
+    function updateRemovedEntity(entity) {
+        const [n, v] = EntityUtils.fromEntityId(entity);
+        // Update the removed entities map
+        removedEntities.addTo(n, v);
+        // Remove the usedEntities if exist
+        for (let i = 0; i <= v; i++) {
+            usedEntities.delete(EntityUtils.toEntityId(n, i));
+        }
+        return true;
+    }
+    function updateUsedEntity(entity) {
+        const [n, v] = EntityUtils.fromEntityId(entity);
+        const removedVersion = removedEntities.getMap().get(n);
+        if (removedVersion !== undefined && removedVersion >= v) {
+            return false;
+        }
+        // Update
+        if (v > 0) {
+            for (let i = 0; i <= v - 1; i++) {
+                usedEntities.delete(EntityUtils.toEntityId(n, i));
+            }
+            removedEntities.addTo(n, v - 1);
+        }
+        usedEntities.add(entity);
+        return true;
+    }
+    function getEntityState(entity) {
+        const [n, v] = EntityUtils.fromEntityId(entity);
+        if (n < RESERVED_STATIC_ENTITIES) {
+            return EntityState.Reserved;
+        }
+        if (usedEntities.has(entity)) {
+            return EntityState.UsedEntity;
+        }
+        const removedVersion = removedEntities.getMap().get(n);
+        if (removedVersion !== undefined && removedVersion >= v) {
+            return EntityState.Removed;
+        }
+        return EntityState.Unknown;
     }
     return {
-        generateEntity() {
-            return generateEntity();
-        },
-        removeEntity(entity) {
-            return removeEntity(entity);
-        },
-        entityExists(entity) {
-            return entity < RESERVED_STATIC_ENTITIES || usedEntities.has(entity);
-        },
+        generateEntity,
+        removeEntity,
         getExistingEntities() {
             return new Set(usedEntities);
         },
-        entityVersion,
-        entityNumber,
-        entityId
+        getEntityState,
+        releaseRemovedEntities,
+        updateRemovedEntity,
+        updateUsedEntity
     };
 }

package/dist/engine/index.js

@@ -22,9 +22,6 @@ function preEngine() {
         const entity = entityContainer.generateEntity();
         return entity;
     }
-    function entityExists(entity) {
-        return entityContainer.entityExists(entity);
-    }
     function removeEntity(entity) {
         for (const [, component] of componentsDefinition) {
             if (component.has(entity)) {
@@ -131,8 +128,6 @@ function preEngine() {
         }
     }
     return {
-        entityExists,
-        componentsDefinition,
         addEntity,
         removeEntity,
         addSystem,
@@ -146,6 +141,7 @@ function preEngine() {
         removeComponentDefinition,
         removeEntityWithChildren,
         registerCustomComponent,
+        entityContainer,
         componentsIter
     };
 }
@@ -162,8 +158,9 @@ export function Engine(options) {
             checkNotThenable(ret, `A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
         }
         const dirtyEntities = crdtSystem.updateState();
-        await crdtSystem.sendMessages(dirtyEntities);
-        for (const [_componentId, definition] of engine.componentsDefinition) {
+        const deletedEntites = engine.entityContainer.releaseRemovedEntities();
+        await crdtSystem.sendMessages(dirtyEntities, deletedEntites);
+        for (const definition of engine.componentsIter()) {
             definition.clearDirty();
         }
     }
@@ -185,9 +182,9 @@ export function Engine(options) {
         RootEntity: 0,
         PlayerEntity: 1,
         CameraEntity: 2,
-        entityExists: engine.entityExists,
+        getEntityState: engine.entityContainer.getEntityState,
         addTransport: crdtSystem.addTransport,
         getCrdtState: crdtSystem.getCrdt,
-        componentsDefinition: engine.componentsDefinition
+        entityContainer: engine.entityContainer
     };
 }

package/dist/engine/types.d.ts

@@ -2,7 +2,7 @@ import type { ISchema } from '../schemas/ISchema';
 import { MapResult, Spec } from '../schemas/Map';
 import { Transport } from '../systems/crdt/types';
 import { ComponentDefinition } from './component';
-import { Entity } from './entity';
+import { Entity, EntityContainer, EntityState } from './entity';
 import { ReadonlyComponentSchema } from './readonly';
 import { SystemFn } from './systems';
 export { ISchema } from '../schemas/ISchema';
@@ -53,11 +53,11 @@ export declare type IEngine = {
      */
     removeEntityWithChildren(firstEntity: Entity): void;
     /**
-     * Check if an entity exists in the engine
+     * Check the state of an entityin  the engine
      * @param entity - the entity to validate
-     * @returns true if the entity exists in the engine
+     * @returns known enum value
      */
-    entityExists(entity: Entity): boolean;
+    getEntityState(entity: Entity): EntityState;
     /**
      * Add the system to the engine. It will be called every tick updated.
      * @param system - function that receives the delta time between last tick and current one.
@@ -173,6 +173,10 @@ export declare type IEngine = {
      * @param transport - transport which changes its onmessage to process CRDT messages
      */
     addTransport(transport: Transport): void;
+    /**
+     * Entity continaer
+     */
+    entityContainer: EntityContainer;
     /**
      * Iterator of registered components
      */

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export declare const MeshRenderer: import("./components/types").MeshRendererComp
 export declare const MeshCollider: import("./components/types").MeshColliderComponentDefinitionExtended;
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';
+export * from './serialization/crdt';

package/dist/index.js

@@ -22,3 +22,4 @@ import { engine } from './runtime/initialization';
 // export components for global engine
 export * from './components/generated/global.gen';
 export * from './components/generated/types.gen';
+export * from './serialization/crdt';

package/dist/runtime/types.d.ts

@@ -1,6 +1,5 @@
 export type { SystemFn } from '../engine/systems';
 export type { TransportMessage, ReceiveMessage, Transport } from '../systems/crdt/types';
-export type { WireMessage } from '../serialization/wireMessage';
 export { TransformType, TransformComponent } from '../components/legacy/Transform';
 export * from '../engine/component';
 export * from '../schemas/typing';

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;
+}

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

@@ -0,0 +1,13 @@
+import { ComponentDefinition } from '../../engine/component';
+import { Entity } from '../../engine/entity';
+import { ByteBuffer } from '../ByteBuffer';
+import { PutComponentMessage } from './types';
+export declare namespace PutComponentOperation {
+    const MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity: Entity, timestamp: number, componentDefinition: ComponentDefinition<unknown>, buf: ByteBuffer): void;
+    function read(buf: ByteBuffer): PutComponentMessage | null;
+}

package/dist/serialization/crdt/putComponent.js

@@ -0,0 +1,44 @@
+import CrdtMessageProtocol from '.';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+export var PutComponentOperation;
+(function (PutComponentOperation) {
+    PutComponentOperation.MESSAGE_HEADER_LENGTH = 20;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity, timestamp, componentDefinition, buf) {
+        // reserve the beginning
+        const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + PutComponentOperation.MESSAGE_HEADER_LENGTH);
+        // write body
+        componentDefinition.writeToByteBuffer(entity, buf);
+        const messageLength = buf.size() - startMessageOffset;
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, CrdtMessageType.PUT_COMPONENT);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentDefinition._id);
+        buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
+        const newLocal = messageLength - PutComponentOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
+        buf.setUint32(startMessageOffset + 24, newLocal);
+    }
+    PutComponentOperation.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        if (!header) {
+            return null;
+        }
+        if (header.type !== CrdtMessageType.PUT_COMPONENT) {
+            throw new Error('PutComponentOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readInt32(),
+            timestamp: Number(buf.readUint64()),
+            data: buf.readBuffer()
+        };
+    }
+    PutComponentOperation.read = read;
+})(PutComponentOperation || (PutComponentOperation = {}));