@dcl/ecs 7.1.12-4982571416.commit-0b87aa7 → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/systems/crdt/utils.d.ts

@@ -0,0 +1,15 @@
+import { ComponentDefinition } from '../../engine/component';
+export declare namespace CrdtUtils {
+    type ComponentID = ComponentDefinition<any>['componentId'];
+    enum SynchronizedEntityType {
+        NETWORKED = 0,
+        RENDERER = 1
+    }
+}
+export default CrdtUtils;
+/**
+ * Compare raw data.
+ * @public
+ * @returns 0 if is the same data, 1 if a > b, -1 if b > a
+ */
+export declare function dataCompare<T>(a: T, b: T): number;

package/dist-cjs/systems/crdt/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataCompare = exports.CrdtUtils = void 0;
+var CrdtUtils;
+(function (CrdtUtils) {
+    let SynchronizedEntityType;
+    (function (SynchronizedEntityType) {
+        // synchronizes entities with the NetworkSynchronized component only, used for networked games
+        SynchronizedEntityType[SynchronizedEntityType["NETWORKED"] = 0] = "NETWORKED";
+        // synchronizes entities needed by the renderer
+        SynchronizedEntityType[SynchronizedEntityType["RENDERER"] = 1] = "RENDERER";
+    })(SynchronizedEntityType = CrdtUtils.SynchronizedEntityType || (CrdtUtils.SynchronizedEntityType = {}));
+})(CrdtUtils = exports.CrdtUtils || (exports.CrdtUtils = {}));
+exports.default = CrdtUtils;
+/**
+ * Compare raw data.
+ * @public
+ * @returns 0 if is the same data, 1 if a > b, -1 if b > a
+ */
+function dataCompare(a, b) {
+    // At reference level
+    if (a === b)
+        return 0;
+    if (a === null && b !== null)
+        return -1;
+    if (a !== null && b === null)
+        return 1;
+    if (a instanceof Uint8Array && b instanceof Uint8Array) {
+        const lengthDifference = a.byteLength - b.byteLength;
+        if (lengthDifference !== 0) {
+            return lengthDifference > 0 ? 1 : -1;
+        }
+        let res;
+        for (let i = 0, n = a.byteLength; i < n; i++) {
+            res = a[i] - b[i];
+            if (res !== 0) {
+                return res > 0 ? 1 : -1;
+            }
+        }
+        // the data is exactly the same
+        return 0;
+    }
+    if (typeof a === 'string') {
+        const lengthDifference = a.length - b.length;
+        if (lengthDifference !== 0) {
+            return lengthDifference > 0 ? 1 : -1;
+        }
+        return a.localeCompare(b);
+    }
+    return a > b ? 1 : -1;
+}
+exports.dataCompare = dataCompare;

package/dist-cjs/systems/cyclicParentingChecker.d.ts

@@ -0,0 +1,17 @@
+import { IEngine } from '../engine/types';
+/**
+ * Transform parenting: cyclic dependency checker
+ * It checks only in modified Transforms
+ *
+ * Add this system with:
+ * ```ts
+ *  engine.addSystem(cyclicParentingChecker(engine))
+ * ````
+ * And then it will check every tick the parenting.
+ *
+ * @public
+ *
+ * @params engine
+ * @returns a system
+ */
+export declare function cyclicParentingChecker(engine: IEngine): () => void;

package/dist-cjs/systems/cyclicParentingChecker.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cyclicParentingChecker = void 0;
+const components = __importStar(require("../components"));
+/**
+ * Transform parenting: cyclic dependency checker
+ * It checks only in modified Transforms
+ *
+ * Add this system with:
+ * ```ts
+ *  engine.addSystem(cyclicParentingChecker(engine))
+ * ````
+ * And then it will check every tick the parenting.
+ *
+ * @public
+ *
+ * @params engine
+ * @returns a system
+ */
+function cyclicParentingChecker(engine) {
+    const Transform = components.Transform(engine);
+    return () => {
+        for (const entity of Transform.dirtyIterator()) {
+            let transform = Transform.getOrNull(entity);
+            while (transform && transform.parent) {
+                if (transform.parent === entity) {
+                    console.error(`There is a cyclic parent with entity ${entity}`);
+                    break;
+                }
+                else {
+                    transform = Transform.getOrNull(transform.parent);
+                }
+            }
+        }
+    };
+}
+exports.cyclicParentingChecker = cyclicParentingChecker;

package/dist-cjs/systems/events.d.ts

@@ -0,0 +1,49 @@
+import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
+import { PBPointerEventsResult } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+import { Entity } from '../engine/entity';
+/**
+ * @public
+ */
+export type EventSystemCallback = (event: PBPointerEventsResult) => void;
+/**
+ * @public
+ */
+export type EventSystemOptions = {
+    button: InputAction;
+    hoverText?: string;
+    maxDistance?: number;
+    showFeedback?: boolean;
+};
+/**
+ * @public
+ */
+export interface PointerEventsSystem {
+    /**
+     * @public
+     * Remove the callback for onPointerDown event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDown(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerUp event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerUp(entity: Entity): void;
+    /**
+     * @public
+     * Execute callback when the user press the InputButton pointing at the entity
+     * @param entity - Entity to attach the callback
+     * @param cb - Function to execute when click fires
+     * @param opts - Opts to trigger Feedback and Button
+     */
+    onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
+    /**
+     * @public
+     * Execute callback when the user releases the InputButton pointing at the entity
+     * @param entity - Entity to attach the callback
+     * @param cb - Function to execute when click fires
+     * @param opts - Opts to trigger Feedback and Button
+     */
+    onPointerUp(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
+}

package/dist-cjs/systems/events.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPointerEventsSystem = void 0;
+const components = __importStar(require("../components"));
+const entity_1 = require("../engine/entity");
+const invariant_1 = require("../runtime/invariant");
+/**
+ * @internal
+ */
+function createPointerEventsSystem(engine, inputSystem) {
+    const PointerEvents = components.PointerEvents(engine);
+    let EventType;
+    (function (EventType) {
+        EventType[EventType["Click"] = 0] = "Click";
+        EventType[EventType["Down"] = 1] = "Down";
+        EventType[EventType["Up"] = 2] = "Up";
+    })(EventType || (EventType = {}));
+    const getDefaultOpts = (opts = {}) => ({
+        button: 3 /* InputAction.IA_ANY */,
+        ...opts
+    });
+    const eventsMap = new Map();
+    function getEvent(entity) {
+        return eventsMap.get(entity) || eventsMap.set(entity, new Map()).get(entity);
+    }
+    function setPointerEvent(entity, type, opts) {
+        if (opts.hoverText || opts.showFeedback) {
+            const pointerEvent = PointerEvents.getMutableOrNull(entity) || PointerEvents.create(entity);
+            pointerEvent.pointerEvents.push({
+                eventType: type,
+                eventInfo: {
+                    button: opts.button,
+                    showFeedback: opts.showFeedback,
+                    hoverText: opts.hoverText,
+                    maxDistance: opts.maxDistance
+                }
+            });
+        }
+    }
+    function removePointerEvent(entity, type, button) {
+        const pointerEvent = PointerEvents.getMutableOrNull(entity);
+        if (!pointerEvent)
+            return;
+        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button && pointer.eventType === type));
+    }
+    function getPointerEvent(eventType) {
+        if (eventType === EventType.Up) {
+            return 0 /* PointerEventType.PET_UP */;
+        }
+        return 1 /* PointerEventType.PET_DOWN */;
+    }
+    function removeEvent(entity, type) {
+        const event = getEvent(entity);
+        const pointerEvent = event.get(type);
+        if (pointerEvent?.opts.hoverText) {
+            removePointerEvent(entity, getPointerEvent(type), pointerEvent.opts.button);
+        }
+        event.delete(type);
+    }
+    // @internal
+    engine.addSystem(function EventSystem() {
+        for (const [entity, event] of eventsMap) {
+            if (engine.getEntityState(entity) === entity_1.EntityState.Removed) {
+                eventsMap.delete(entity);
+                continue;
+            }
+            for (const [eventType, { cb, opts }] of event) {
+                if (eventType === EventType.Click) {
+                    const command = inputSystem.getClick(opts.button, entity);
+                    if (command)
+                        (0, invariant_1.checkNotThenable)(cb(command.up), 'Click event returned a thenable. Only synchronous functions are allowed');
+                }
+                if (eventType === EventType.Down || eventType === EventType.Up) {
+                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
+                    if (command) {
+                        (0, invariant_1.checkNotThenable)(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                    }
+                }
+            }
+        }
+    });
+    return {
+        removeOnClick(entity) {
+            removeEvent(entity, EventType.Click);
+        },
+        removeOnPointerDown(entity) {
+            removeEvent(entity, EventType.Down);
+        },
+        removeOnPointerUp(entity) {
+            removeEvent(entity, EventType.Up);
+        },
+        onClick(entity, cb, opts) {
+            const options = getDefaultOpts(opts);
+            // Clear previous event with over feedback included
+            removeEvent(entity, EventType.Click);
+            // Set new event
+            getEvent(entity).set(EventType.Click, { cb, opts: options });
+            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
+        },
+        onPointerDown(entity, cb, opts) {
+            const options = getDefaultOpts(opts);
+            removeEvent(entity, EventType.Down);
+            getEvent(entity).set(EventType.Down, { cb, opts: options });
+            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
+        },
+        onPointerUp(entity, cb, opts) {
+            const options = getDefaultOpts(opts);
+            removeEvent(entity, EventType.Up);
+            getEvent(entity).set(EventType.Up, { cb, opts: options });
+            setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
+        }
+    };
+}
+exports.createPointerEventsSystem = createPointerEventsSystem;

package/dist-cjs/systems/raycast.d.ts

@@ -0,0 +1,80 @@
+import { RaycastQueryType, PBRaycastResult } from '../components';
+import { DeepReadonlyObject, Entity } from '../engine';
+import { Vector3 } from '../components/generated/pb/decentraland/common/vectors.gen';
+/**
+ * @public
+ */
+export type RaycastSystemCallback = (event: DeepReadonlyObject<PBRaycastResult>) => void;
+/**
+ * @public
+ */
+export type RaycastSystemOptions = {
+    originOffset?: Vector3 | undefined;
+    maxDistance: number;
+    queryType: RaycastQueryType;
+    continuous?: boolean | undefined;
+    collisionMask?: number | undefined;
+};
+export type LocalDirectionRaycastSystemOptions = {
+    direction?: Vector3;
+};
+export type LocalDirectionRaycastOptions = RaycastSystemOptions & LocalDirectionRaycastSystemOptions;
+export type GlobalDirectionRaycastSystemOptions = {
+    direction?: Vector3;
+};
+export type GlobalDirectionRaycastOptions = RaycastSystemOptions & GlobalDirectionRaycastSystemOptions;
+export type GlobalTargetRaycastSystemOptions = {
+    target?: Vector3;
+};
+export type GlobalTargetRaycastOptions = RaycastSystemOptions & GlobalTargetRaycastSystemOptions;
+export type TargetEntityRaycastSystemOptions = {
+    targetEntity?: number;
+};
+export type TargetEntityRaycastOptions = RaycastSystemOptions & TargetEntityRaycastSystemOptions;
+/**
+ * @public
+ */
+export interface RaycastSystem {
+    /**
+     * @public
+     * Remove the callback for raycast event
+     * @param entity - Entity where the callback was attached
+     */
+    removeRaycasterEntity(entity: Entity): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses a Vector3 entity-local direction value to calculate the ray direction
+     * @param entity - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     * @param options - Raycast configuration options
+     */
+    registerLocalDirectionRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<LocalDirectionRaycastOptions>): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses a Vector3 global direction value to calculate the ray direction
+     * @param entity - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     * @param options - Raycast configuration options
+     */
+    registerGlobalDirectionRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<GlobalDirectionRaycastOptions>): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses a Vector3 global target position to calculate the ray direction
+     * @param entity - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     * @param options - Raycast configuration options
+     */
+    registerGlobalTargetRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<GlobalTargetRaycastOptions>): void;
+    /**
+     * @public
+     * Execute callback when the entity receives a RaycastResult component update.
+     * Uses an target Entity value to calculate the ray direction
+     * @param entity - Entity to attach the callback
+     * @param callback - Function to execute when the entity's RaycastResult component is updated
+     * @param options - Raycast configuration options
+     */
+    registerTargetEntityRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<TargetEntityRaycastOptions>): void;
+}

package/dist-cjs/systems/raycast.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRaycastSystem = void 0;
+const components = __importStar(require("../components"));
+const entity_1 = require("../engine/entity");
+/**
+ * @internal
+ */
+function createRaycastSystem(engine) {
+    const raycastComponent = components.Raycast(engine);
+    const raycastResultComponent = components.RaycastResult(engine);
+    const entitiesCallbackResultMap = new Map();
+    const defaultOptions = {
+        maxDistance: 16,
+        queryType: 0 /* RaycastQueryType.RQT_HIT_FIRST */,
+        continuous: false,
+        originOffset: { x: 0, y: 0, z: 0 },
+        collisionMask: 2 /* ColliderLayer.CL_PHYSICS */
+    };
+    const getLocalDirectionRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'localDirection',
+            localDirection: options.direction || { x: 0, y: 0, z: 1 }
+        }
+    });
+    const getGlobalDirectionRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'globalDirection',
+            globalDirection: options.direction || { x: 0, y: 0, z: 1 }
+        }
+    });
+    const getGlobalTargetRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'globalTarget',
+            globalTarget: options.target || { x: 0, y: 0, z: 0 }
+        }
+    });
+    const getTargetEntityRaycastDefaultOptions = (options = {}) => ({
+        ...defaultOptions,
+        ...options,
+        directionRawValue: {
+            $case: 'targetEntity',
+            targetEntity: options.targetEntity || 0
+        }
+    });
+    function registerRaycast(entity, callback, options) {
+        const raycast = raycastComponent.getOrCreateMutable(entity);
+        raycast.maxDistance = options.maxDistance;
+        raycast.originOffset = options.originOffset;
+        raycast.collisionMask = options.collisionMask;
+        raycast.direction = options.directionRawValue;
+        raycast.continuous = options.continuous;
+        raycast.queryType = options.queryType;
+        entitiesCallbackResultMap.set(entity, { callback: callback });
+    }
+    function removeRaycast(entity) {
+        raycastComponent.deleteFrom(entity);
+        raycastResultComponent.deleteFrom(entity);
+        entitiesCallbackResultMap.delete(entity);
+    }
+    // @internal
+    engine.addSystem(function EventSystem() {
+        for (const [entity, data] of entitiesCallbackResultMap) {
+            const raycast = raycastComponent.getOrNull(entity);
+            if (engine.getEntityState(entity) === entity_1.EntityState.Removed || !raycast) {
+                entitiesCallbackResultMap.delete(entity);
+                continue;
+            }
+            const currentResult = raycastResultComponent.getOrNull(entity);
+            if (!currentResult)
+                continue;
+            data.callback(currentResult);
+            if (!raycast.continuous)
+                removeRaycast(entity);
+        }
+    });
+    return {
+        removeRaycasterEntity(entity) {
+            removeRaycast(entity);
+        },
+        registerLocalDirectionRaycast(entity, callback, opts) {
+            registerRaycast(entity, callback, getLocalDirectionRaycastDefaultOptions(opts));
+        },
+        registerGlobalDirectionRaycast(entity, callback, opts) {
+            registerRaycast(entity, callback, getGlobalDirectionRaycastDefaultOptions(opts));
+        },
+        registerGlobalTargetRaycast(entity, callback, opts) {
+            registerRaycast(entity, callback, getGlobalTargetRaycastDefaultOptions(opts));
+        },
+        registerTargetEntityRaycast(entity, callback, opts) {
+            registerRaycast(entity, callback, getTargetEntityRaycastDefaultOptions(opts));
+        }
+    };
+}
+exports.createRaycastSystem = createRaycastSystem;

package/dist-cjs/systems/videoEvents.d.ts

@@ -0,0 +1,14 @@
+import { DeepReadonlyObject, Entity } from '../engine';
+import { PBVideoEvent } from '../components';
+/**
+ * @public
+ */
+export type VideoEventsSystemCallback = (event: DeepReadonlyObject<PBVideoEvent>) => void;
+/**
+ * @public
+ */
+export interface VideoEventsSystem {
+    removeVideoEventsEntity(entity: Entity): void;
+    registerVideoEventsEntity(entity: Entity, callback: VideoEventsSystemCallback): void;
+    hasVideoEventsEntity(entity: Entity): boolean;
+}

package/dist-cjs/systems/videoEvents.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVideoEventsSystem = void 0;
+const components = __importStar(require("../components"));
+const entity_1 = require("../engine/entity");
+/**
+ * @internal
+ */
+function createVideoEventsSystem(engine) {
+    const videoPlayerComponent = components.VideoPlayer(engine);
+    const videoEventComponent = components.VideoEvent(engine);
+    const entitiesCallbackVideoStateMap = new Map();
+    function registerVideoEventsEntity(entity, callback) {
+        // video event component is not added here because the renderer adds it
+        // to every entity with a VideoPlayer component
+        entitiesCallbackVideoStateMap.set(entity, { callback: callback });
+    }
+    function removeVideoEventsEntity(entity) {
+        entitiesCallbackVideoStateMap.delete(entity);
+    }
+    function hasVideoEventsEntity(entity) {
+        return entitiesCallbackVideoStateMap.has(entity);
+    }
+    // @internal
+    engine.addSystem(function EventSystem() {
+        for (const [entity, data] of entitiesCallbackVideoStateMap) {
+            const videoPlayer = videoPlayerComponent.getOrNull(entity);
+            if (engine.getEntityState(entity) === entity_1.EntityState.Removed || !videoPlayer) {
+                removeVideoEventsEntity(entity);
+                continue;
+            }
+            // Compare with last state
+            const videoEvent = videoEventComponent.get(entity);
+            const values = videoEvent.values();
+            const valuesAmount = videoEvent.size;
+            let latestVideoEventComponentState = undefined;
+            // get latest component state
+            let index = 0;
+            for (const value of values) {
+                if (index === valuesAmount - 1)
+                    latestVideoEventComponentState = value;
+                index++;
+            }
+            if (latestVideoEventComponentState === undefined ||
+                (data.lastVideoState !== undefined && data.lastVideoState === latestVideoEventComponentState.state))
+                continue;
+            data.callback(latestVideoEventComponentState);
+            entitiesCallbackVideoStateMap.set(entity, {
+                callback: data.callback,
+                lastVideoState: latestVideoEventComponentState.state
+            });
+        }
+    });
+    return {
+        removeVideoEventsEntity(entity) {
+            removeVideoEventsEntity(entity);
+        },
+        registerVideoEventsEntity(entity, callback) {
+            registerVideoEventsEntity(entity, callback);
+        },
+        hasVideoEventsEntity(entity) {
+            return hasVideoEventsEntity(entity);
+        }
+    };
+}
+exports.createVideoEventsSystem = createVideoEventsSystem;

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.1.12-4982571416.commit-0b87aa7",
+  "version": "7.1.12-4983011170.commit-adaaaa2",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "dependencies": {
-    "@dcl/js-runtime": "7.1.12-4982571416.commit-0b87aa7"
+    "@dcl/js-runtime": "7.1.12-4983011170.commit-adaaaa2"
   },
   "files": [
     "dist",
+    "dist-cjs",
     "etc"
   ],
   "homepage": "https://github.com/decentraland/ecs#readme",
@@ -24,7 +25,7 @@
     "directory": "packages/@dcl/ecs"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json"
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json"
   },
   "typedoc": {
     "entryPoint": "./src/index.ts",
@@ -34,5 +35,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "0b87aa748eb15b71ae76fc44a287b12b913d1eff"
+  "commit": "adaaaa2d4cd6e50fe3d5bbd76cbcb3779aa3da51"
 }