@dcl/ecs 7.0.6-4177592674.commit-39cdc99 → 7.0.6-4183962432.commit-2fbe270

package/dist/components/generated/pb/decentraland/sdk/components/pointer_events_result.gen.js

@@ -3,40 +3,6 @@ import _m0 from "protobufjs/minimal";
 import { RaycastHit } from "./raycast_result.gen";
 const protobufPackageSarasa = "decentraland.sdk.components";
 function createBasePBPointerEventsResult() {
-    return { commands: [] };
-}
-/**
- * @public
- */
-/**
- * @internal
- */
-export const PBPointerEventsResult = {
-    encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.commands) {
-            PBPointerEventsResult_PointerCommand.encode(v, writer.uint32(10).fork()).ldelim();
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBasePBPointerEventsResult();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.commands.push(PBPointerEventsResult_PointerCommand.decode(reader, reader.uint32()));
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-};
-function createBasePBPointerEventsResult_PointerCommand() {
     return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined };
 }
 /**
@@ -45,7 +11,7 @@ function createBasePBPointerEventsResult_PointerCommand() {
 /**
  * @internal
  */
-export const PBPointerEventsResult_PointerCommand = {
+export const PBPointerEventsResult = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.button !== 0) {
             writer.uint32(8).int32(message.button);
@@ -67,7 +33,7 @@ export const PBPointerEventsResult_PointerCommand = {
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBasePBPointerEventsResult_PointerCommand();
+        const message = createBasePBPointerEventsResult();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {

package/dist/components/index.d.ts

@@ -1,14 +1,14 @@
-import { ComponentDefinition } from '../engine/component';
+import { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition } from '../engine/component';
 import { AnimatorComponentDefinitionExtended } from './extended/Animator';
 import { MaterialComponentDefinitionExtended } from './extended/Material';
 import { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
 import { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
-import { ComponentGetter } from './generated/index.gen';
-import { TransformComponentExtended } from './legacy/Transform';
+import { LwwComponentGetter, GSetComponentGetter } from './generated/index.gen';
+import { TransformComponentExtended } from './manual/Transform';
 export * from './generated/index.gen';
-export type { ComponentDefinition, ComponentGetter };
-export declare const Transform: ComponentGetter<TransformComponentExtended>;
-export declare const Material: ComponentGetter<MaterialComponentDefinitionExtended>;
-export declare const Animator: ComponentGetter<AnimatorComponentDefinitionExtended>;
-export declare const MeshRenderer: ComponentGetter<MeshRendererComponentDefinitionExtended>;
-export declare const MeshCollider: ComponentGetter<MeshColliderComponentDefinitionExtended>;
+export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
+export declare const Transform: LwwComponentGetter<TransformComponentExtended>;
+export declare const Material: LwwComponentGetter<MaterialComponentDefinitionExtended>;
+export declare const Animator: LwwComponentGetter<AnimatorComponentDefinitionExtended>;
+export declare const MeshRenderer: LwwComponentGetter<MeshRendererComponentDefinitionExtended>;
+export declare const MeshCollider: LwwComponentGetter<MeshColliderComponentDefinitionExtended>;

package/dist/components/index.js

@@ -2,7 +2,7 @@ import { defineAnimatorComponent } from './extended/Animator';
 import { defineMaterialComponent } from './extended/Material';
 import { defineMeshColliderComponent } from './extended/MeshCollider';
 import { defineMeshRendererComponent } from './extended/MeshRenderer';
-import { defineTransformComponent } from './legacy/Transform';
+import { defineTransformComponent } from './manual/Transform';
 export * from './generated/index.gen';
 /*#__PURE__*/
 export const Transform = (engine) => defineTransformComponent(engine);

package/dist/components/{legacy → manual}/Transform.d.ts

@@ -1,9 +1,9 @@
-import { ComponentDefinition, IEngine } from '../../engine';
+import { LastWriteWinElementSetComponentDefinition, IEngine } from '../../engine';
 import { Entity } from '../../engine/entity';
 /**
  * @public
  */
-export type TransformComponent = ComponentDefinition<TransformType>;
+export type TransformComponent = LastWriteWinElementSetComponentDefinition<TransformType>;
 /**
  * @public
  */

package/dist/components/{legacy → manual}/Transform.js

@@ -58,6 +58,38 @@ export const TransformSchema = {
             parent: 0,
             ...value
         };
+    },
+    jsonSchema: {
+        type: 'object',
+        properties: {
+            position: {
+                type: 'object',
+                properties: {
+                    x: { type: 'number' },
+                    y: { type: 'number' },
+                    z: { type: 'number' }
+                }
+            },
+            scale: {
+                type: 'object',
+                properties: {
+                    x: { type: 'number' },
+                    y: { type: 'number' },
+                    z: { type: 'number' }
+                }
+            },
+            rotation: {
+                type: 'object',
+                properties: {
+                    x: { type: 'number' },
+                    y: { type: 'number' },
+                    z: { type: 'number' },
+                    w: { type: 'number' }
+                }
+            },
+            parent: { type: 'integer' }
+        },
+        serializationType: 'transform'
     }
 };
 export function defineTransformComponent(engine) {

package/dist/components/types.d.ts

@@ -2,4 +2,4 @@ export type { AnimatorComponentDefinitionExtended } from './extended/Animator';
 export type { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
 export type { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
 export type { TextureHelper, MaterialComponentDefinitionExtended } from './extended/Material';
-export type { TransformComponentExtended, TransformTypeWithOptionals } from './legacy/Transform';
+export type { TransformComponentExtended, TransformTypeWithOptionals } from './manual/Transform';

package/dist/engine/component.d.ts

@@ -1,24 +1,72 @@
-import type { ISchema } from '../schemas/ISchema';
+import { ISchema } from '../schemas';
 import { CrdtMessageBody, DeleteComponentMessageBody, PutComponentMessageBody } from '../serialization/crdt';
 import { Entity } from './entity';
-import { DeepReadonly } from './readonly';
+import { DeepReadonly, DeepReadonlySet } from './readonly';
 /**
+ * Component types are used to pick the wire protocol and the conflict resolution algorithm
  * @public
  */
-export interface ComponentDefinition<T> {
+export declare const enum ComponentType {
+    LastWriteWinElementSet = 0,
+    GrowOnlyValueSet = 1
+}
+/**
+ * A conflict resolution message is the response to an outdated or invalid state
+ * in the CRDT.
+ * @public
+ */
+export type ConflictResolutionMessage = PutComponentMessageBody | DeleteComponentMessageBody;
+/**
+ * @public
+ */
+export interface BaseComponent<T> {
     readonly componentId: number;
     readonly componentName: string;
+    readonly componentType: ComponentType;
+    readonly schema: ISchema<T>;
+    /**
+     * This function receives a CRDT update and returns a touple with a "conflict
+     * resoluton" message, in case of the sender being updated or null in case of noop/accepted
+     * change. The second element of the touple is the modified/changed/deleted value.
+     * @public
+     */
+    updateFromCrdt(body: CrdtMessageBody): [null | ConflictResolutionMessage, T | undefined];
+    /**
+     * This function returns an iterable with all the CRDT updates that need to be
+     * broadcasted to other actors in the system. After returning, this function
+     * clears the internal dirty state. Updates are produced only once.
+     * @public
+     */
+    getCrdtUpdates(): Iterable<CrdtMessageBody>;
     /**
-     * Return the default value of the current component
+     * @public
+     * Marks the entity as deleted and signals it cannot be used ever again. It must
+     * clear the component internal state, produces a synchronization message to remove
+     * the component from the entity.
+     * @param entity - Entity ID that was deleted.
      */
-    default(): DeepReadonly<T>;
+    entityDeleted(entity: Entity, markAsDirty: boolean): void;
     /**
      * Get if the entity has this component
      * @param entity - entity to test
      */
     has(entity: Entity): boolean;
     /**
-     * Get the readonly component of the entity (to mutate it, use getMutable instead), throw an error if the entity doesn't have the component.
+     * Get the readonly component of the entity (to mutate it, use getMutable instead),
+     * throws an error if the entity doesn't have the component.
+     * @param entity - Entity that will be used to get the component
+     * @returns
+     */
+    get(entity: Entity): any;
+}
+/**
+ * @public
+ */
+export interface LastWriteWinElementSetComponentDefinition<T> extends BaseComponent<T> {
+    readonly componentType: ComponentType.LastWriteWinElementSet;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead),
+     * throws an error if the entity doesn't have the component.
      * @param entity - Entity that will be used to get the component
      * @returns
      */
@@ -49,14 +97,6 @@ export interface ComponentDefinition<T> {
      * @param entity - Entity to delete the component from
      */
     deleteFrom(entity: Entity): T | null;
-    /**
-     * @public
-     * Marks the entity as deleted and signals it cannot be used ever again. It must
-     * clear the component internal state, produces a synchronization message to remove
-     * the component from the entity.
-     * @param entity - Entity to delete the component from
-     */
-    entityDeleted(entity: Entity, markAsDirty: boolean): void;
     /**
      * Get the mutable component of the entity, throw an error if the entity doesn't have the component.
      * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
@@ -69,21 +109,28 @@ export interface ComponentDefinition<T> {
      * @param entity - Entity to get the component from
      */
     getMutableOrNull(entity: Entity): T | null;
+}
+/**
+ * @public
+ */
+export interface GrowOnlyValueSetComponentDefinition<T> extends BaseComponent<T> {
+    readonly componentType: ComponentType.GrowOnlyValueSet;
     /**
-     * This function receives a CRDT update and returns a touple with a "conflict
-     * resoluton" message, in case of the sender being updated or null in case of noop/accepted
-     * change. The second element of the touple is the modified/changed/deleted value.
-     * @public
+     * Appends an element to the set.
+     * @param entity - Entity that will host the value
+     * @param val - The final value. The Set will freeze the value, it won't be editable from
+     * the script.
      */
-    updateFromCrdt(body: CrdtMessageBody): [null | PutComponentMessageBody | DeleteComponentMessageBody, T | null];
+    addValue(entity: Entity, val: DeepReadonly<T>): DeepReadonlySet<T>;
     /**
-     * This function returns an iterable with all the CRDT updates that need to be
-     * broadcasted to other actors in the system. After returning, this function
-     * clears the internal dirty state. Updates are produced only once.
-     * @public
+     * Get the readonly component of the entity (to mutate it, use getMutable instead),
+     * throws an error if the entity doesn't have the component.
+     * @param entity - Entity that will be used to get the component
+     * @returns
      */
-    getCrdtUpdates(): Iterable<CrdtMessageBody>;
+    get(entity: Entity): DeepReadonlySet<T>;
 }
-export declare function incrementTimestamp(entity: Entity, timestamps: Map<Entity, number>): number;
-export declare function createUpdateFromCrdt(componentId: number, timestamps: Map<Entity, number>, schema: Pick<ISchema<any>, 'serialize' | 'deserialize'>, data: Map<Entity, unknown>): (msg: CrdtMessageBody) => [null | PutComponentMessageBody | DeleteComponentMessageBody, any];
-export declare function createGetCrdtMessages(componentId: number, timestamps: Map<Entity, number>, dirtyIterator: Set<Entity>, schema: Pick<ISchema<any>, 'serialize'>, data: Map<Entity, unknown>): () => Generator<PutComponentMessageBody | DeleteComponentMessageBody, void, unknown>;
+/**
+ * @public
+ */
+export type ComponentDefinition<T> = LastWriteWinElementSetComponentDefinition<T> | GrowOnlyValueSetComponentDefinition<T>;

package/dist/engine/component.js

@@ -1,242 +1,9 @@
-import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
-import { CrdtMessageType, ProcessMessageResultType } from '../serialization/crdt';
-import { dataCompare } from '../systems/crdt/utils';
-import { deepReadonly } from './readonly';
-export function incrementTimestamp(entity, timestamps) {
-    const newTimestamp = (timestamps.get(entity) || 0) + 1;
-    timestamps.set(entity, newTimestamp);
-    return newTimestamp;
-}
-export function createUpdateFromCrdt(componentId, timestamps, schema, data) {
-    /**
-     * Process the received message only if the lamport number recieved is higher
-     * than the stored one. If its lower, we spread it to the network to correct the peer.
-     * If they are equal, the bigger raw data wins.
-  
-      * Returns the recieved data if the lamport number was bigger than ours.
-      * If it was an outdated message, then we return void
-      * @public
-      */
-    function crdtRuleForCurrentState(message) {
-        const { entityId, timestamp } = message;
-        const currentTimestamp = timestamps.get(entityId);
-        // The received message is > than our current value, update our state.components.
-        if (currentTimestamp === undefined || currentTimestamp < timestamp) {
-            return ProcessMessageResultType.StateUpdatedTimestamp;
-        }
-        // Outdated Message. Resend our state message through the wire.
-        if (currentTimestamp > timestamp) {
-            // console.log('2', currentTimestamp, timestamp)
-            return ProcessMessageResultType.StateOutdatedTimestamp;
-        }
-        // Deletes are idempotent
-        if (message.type === CrdtMessageType.DELETE_COMPONENT && !data.has(entityId)) {
-            return ProcessMessageResultType.NoChanges;
-        }
-        let currentDataGreater = 0;
-        if (data.has(entityId)) {
-            const writeBuffer = new ReadWriteByteBuffer();
-            schema.serialize(data.get(entityId), writeBuffer);
-            currentDataGreater = dataCompare(writeBuffer.toBinary(), message.data || null);
-        }
-        else {
-            currentDataGreater = dataCompare(null, message.data);
-        }
-        // Same data, same timestamp. Weirdo echo message.
-        // console.log('3', currentDataGreater, writeBuffer.toBinary(), (message as any).data || null)
-        if (currentDataGreater === 0) {
-            return ProcessMessageResultType.NoChanges;
-        }
-        else if (currentDataGreater > 0) {
-            // Current data is greater
-            return ProcessMessageResultType.StateOutdatedData;
-        }
-        else {
-            // Curent data is lower
-            return ProcessMessageResultType.StateUpdatedData;
-        }
-    }
-    return (msg) => {
-        /* istanbul ignore next */
-        if (msg.type !== CrdtMessageType.PUT_COMPONENT && msg.type !== CrdtMessageType.DELETE_COMPONENT)
-            /* istanbul ignore next */
-            return [null, data.get(msg.entityId)];
-        const action = crdtRuleForCurrentState(msg);
-        const entity = msg.entityId;
-        switch (action) {
-            case ProcessMessageResultType.StateUpdatedData:
-            case ProcessMessageResultType.StateUpdatedTimestamp: {
-                timestamps.set(entity, msg.timestamp);
-                if (msg.type === CrdtMessageType.PUT_COMPONENT) {
-                    const buf = new ReadWriteByteBuffer(msg.data);
-                    data.set(entity, schema.deserialize(buf));
-                }
-                else {
-                    data.delete(entity);
-                }
-                return [null, data.get(entity)];
-            }
-            case ProcessMessageResultType.StateOutdatedTimestamp:
-            case ProcessMessageResultType.StateOutdatedData: {
-                if (data.has(entity)) {
-                    const writeBuffer = new ReadWriteByteBuffer();
-                    schema.serialize(data.get(entity), writeBuffer);
-                    return [
-                        {
-                            type: CrdtMessageType.PUT_COMPONENT,
-                            componentId,
-                            data: writeBuffer.toBinary(),
-                            entityId: entity,
-                            timestamp: timestamps.get(entity)
-                        },
-                        data.get(entity)
-                    ];
-                }
-                else {
-                    return [
-                        {
-                            type: CrdtMessageType.DELETE_COMPONENT,
-                            componentId,
-                            entityId: entity,
-                            timestamp: timestamps.get(entity)
-                        },
-                        undefined
-                    ];
-                }
-            }
-        }
-        return [null, data.get(entity)];
-    };
-}
-export function createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data) {
-    return function* () {
-        for (const entity of dirtyIterator) {
-            const newTimestamp = incrementTimestamp(entity, timestamps);
-            if (data.has(entity)) {
-                const writeBuffer = new ReadWriteByteBuffer();
-                schema.serialize(data.get(entity), writeBuffer);
-                const msg = {
-                    type: CrdtMessageType.PUT_COMPONENT,
-                    componentId,
-                    entityId: entity,
-                    data: writeBuffer.toBinary(),
-                    timestamp: newTimestamp
-                };
-                yield msg;
-            }
-            else {
-                const msg = {
-                    type: CrdtMessageType.DELETE_COMPONENT,
-                    componentId,
-                    entityId: entity,
-                    timestamp: newTimestamp
-                };
-                yield msg;
-            }
-        }
-        dirtyIterator.clear();
-    };
-}
 /**
- * @internal
+ * Component types are used to pick the wire protocol and the conflict resolution algorithm
+ * @public
  */
-export function createComponentDefinitionFromSchema(componentName, componentId, schema) {
-    const data = new Map();
-    const dirtyIterator = new Set();
-    const timestamps = new Map();
-    return {
-        get componentId() {
-            return componentId;
-        },
-        get componentName() {
-            return componentName;
-        },
-        default() {
-            return schema.create();
-        },
-        isDirty(entity) {
-            return dirtyIterator.has(entity);
-        },
-        has(entity) {
-            return data.has(entity);
-        },
-        deleteFrom(entity, markAsDirty = true) {
-            const component = data.get(entity);
-            if (data.delete(entity) && markAsDirty) {
-                dirtyIterator.add(entity);
-            }
-            return component || null;
-        },
-        entityDeleted(entity, markAsDirty) {
-            if (data.delete(entity) && markAsDirty) {
-                dirtyIterator.add(entity);
-            }
-        },
-        getOrNull(entity) {
-            const component = data.get(entity);
-            return component ? deepReadonly(component) : null;
-        },
-        get(entity) {
-            const component = data.get(entity);
-            if (!component) {
-                throw new Error(`[getFrom] Component ${componentName} for entity #${entity} not found`);
-            }
-            return deepReadonly(component);
-        },
-        create(entity, value) {
-            const component = data.get(entity);
-            if (component) {
-                throw new Error(`[create] Component ${componentName} for ${entity} already exists`);
-            }
-            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
-            data.set(entity, usedValue);
-            dirtyIterator.add(entity);
-            return usedValue;
-        },
-        createOrReplace(entity, value) {
-            const usedValue = value === undefined ? schema.create() : schema.extend ? schema.extend(value) : value;
-            data.set(entity, usedValue);
-            dirtyIterator.add(entity);
-            return usedValue;
-        },
-        getMutableOrNull(entity) {
-            const component = data.get(entity);
-            if (!component) {
-                return null;
-            }
-            dirtyIterator.add(entity);
-            return component;
-        },
-        getMutable(entity) {
-            const component = this.getMutableOrNull(entity);
-            if (component === null) {
-                throw new Error(`[mutable] Component ${componentName} for ${entity} not found`);
-            }
-            return component;
-        },
-        *iterator() {
-            for (const [entity, component] of data) {
-                yield [entity, component];
-            }
-        },
-        *dirtyIterator() {
-            for (const entity of dirtyIterator) {
-                yield entity;
-            }
-        },
-        getCrdtUpdates: createGetCrdtMessages(componentId, timestamps, dirtyIterator, schema, data),
-        toBinary(entity) {
-            const component = data.get(entity);
-            if (!component) {
-                throw new Error(`[toBinary] Component ${componentName} for ${entity} not found`);
-            }
-            const writeBuffer = new ReadWriteByteBuffer();
-            schema.serialize(component, writeBuffer);
-            return writeBuffer;
-        },
-        updateFromCrdt: createUpdateFromCrdt(componentId, timestamps, schema, data),
-        deserialize(buffer) {
-            return schema.deserialize(buffer);
-        }
-    };
-}
+export var ComponentType;
+(function (ComponentType) {
+    ComponentType[ComponentType["LastWriteWinElementSet"] = 0] = "LastWriteWinElementSet";
+    ComponentType[ComponentType["GrowOnlyValueSet"] = 1] = "GrowOnlyValueSet";
+})(ComponentType || (ComponentType = {}));

package/dist/engine/grow-only-value-set-component-definition.d.ts

@@ -0,0 +1,8 @@
+import { DeepReadonly } from './readonly';
+/**
+ * @public
+ */
+export type ValueSetOptions<T> = {
+    timestampFunction: (value: DeepReadonly<T>) => number;
+    maxElements: number;
+};