@dcl/ecs 7.1.12-4982829389.commit-f2f84bd → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/engine/types.d.ts

@@ -0,0 +1,215 @@
+import type { ISchema } from '../schemas/ISchema';
+import { MapResult, Spec } from '../schemas/Map';
+import { OnChangeFunction } from '../systems/crdt';
+import { Transport } from '../systems/crdt/types';
+import { ComponentDefinition, GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition } from './component';
+import { Entity, EntityState } from './entity';
+import { ValueSetOptions } from './grow-only-value-set-component-definition';
+import { ReadonlyComponentSchema } from './readonly';
+import { SystemFn } from './systems';
+export * from './component';
+export { ValueSetOptions };
+/**
+ * @public
+ */
+export type Unpacked<T> = T extends (infer U)[] ? U : T;
+/**
+ * @public
+ * Overrides component definition to support partial default values
+ */
+export interface MapComponentDefinition<T> extends LastWriteWinElementSetComponentDefinition<T> {
+    /**
+     * Add the current component to an entity, throw an error if the component already exists (use `createOrReplace` instead).
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity that will be used to create the component
+     * @param val - The initial value
+     */
+    create(entity: Entity, val?: Partial<T>): T;
+    /**
+     * Add the current component to an entity or replace the content if the entity already has the component
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity that will be used to create or replace the component
+     * @param val - The initial or new value
+     */
+    createOrReplace(entity: Entity, val?: Partial<T>): T;
+}
+/**
+ * @public
+ */
+export interface IEngineOptions {
+    onChangeFunction: OnChangeFunction;
+}
+/**
+ * @public
+ */
+export interface IEngine {
+    /**
+     * @public
+     * Increment the used entity counter and return the next one.
+     * @param dynamic - whether or no the entity should be considered as Dynamic (vs Static)
+     * @returns the next entity unused
+     */
+    addEntity(dynamic?: boolean): Entity;
+    /**
+     * @public
+     * Remove all components of an entity
+     * @param entity - entity
+     */
+    removeEntity(entity: Entity): void;
+    /**
+     *
+     * @public
+     * Check the state of an entityin  the engine
+     * @param entity - the entity to validate
+     * @returns EntityState enum
+     */
+    getEntityState(entity: Entity): EntityState;
+    /**
+     * @public
+     * 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.
+     * @param priority - a number with the priority, big number are called before smaller ones
+     * @param name - optional: a unique name to identify it
+     *
+     * @example
+     * ```ts
+     * function mySystem(dt: number) {
+     *   const entitiesWithMeshRenderer = engine.getEntitiesWith(MeshRenderer, Transform)
+     *   for (const [entity, _meshRenderer, _transform] of engine.getEntitiesWith(MeshRenderer, Transform)) {
+     *     // do stuffs
+     *   }
+     * }
+     * engine.addSystem(mySystem, 10)
+     * ```
+     */
+    addSystem(system: SystemFn, priority?: number, name?: string): void;
+    /**
+     * @public
+     * Remove a system from the engine.
+     * @param selector - the function or the unique name to identify
+     * @returns if it was found and removed
+     */
+    removeSystem(selector: string | SystemFn): boolean;
+    /**
+     * @public
+     * Registers a custom component definition.
+     * @param componentName - unique name to identify the component, a hash is calculated for it, it will fail if the hash has collisions.
+     * @param componentDefinition - The component definition
+     */
+    registerComponentDefinition<T>(componentName: string, componentDefinition: ComponentDefinition<T>): ComponentDefinition<T>;
+    /**
+     * @public
+     * Define a component and add it to the engine.
+     * @param componentName - unique name to identify the component, a hash is calculated for it, it will fail if the hash has collisions.
+     * @param spec - An object with schema fields
+     * @param constructorDefault - the initial value prefilled when a component is created without a value
+     * @returns The component definition
+     *
+     * @example
+     * ```ts
+     * const CustomComponent = engine.defineComponent("my-scene::custom-name", {
+     *   id: Schemas.Int,
+     *   name: Schemas.String
+     * })
+     * ```
+     */
+    defineComponent<T extends Spec>(componentName: string, spec: T, constructorDefault?: Partial<MapResult<T>>): MapComponentDefinition<MapResult<T>>;
+    /**
+     * @public
+     * Define a component and add it to the engine.
+     * @param componentName - unique name to identify the component, a hash is calculated for it, it will fail if the hash has collisions.
+     * @param spec - An object with schema fields
+     * @returns The component definition
+     *
+     * @example
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.defineComponentFromSchema("my-lib::VisibleComponent", Schemas.Bool)
+     * ```
+     */
+    defineComponentFromSchema<T>(componentName: string, spec: ISchema<T>): LastWriteWinElementSetComponentDefinition<T>;
+    /**
+     * @public
+     * Defines a value set component.
+     * @param componentName - unique name to identify the component, a hash is calculated for it, it will fail if the hash has collisions.
+     * @param spec - An object with schema fields
+     * @returns The component definition
+     *
+     * @example
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.defineValueSetComponentFromSchema("my-lib::VisibleComponent", Schemas.Int)
+     * ```
+     */
+    defineValueSetComponentFromSchema<T>(componentName: string, spec: ISchema<T>, options: ValueSetOptions<T>): GrowOnlyValueSetComponentDefinition<T>;
+    /**
+     * @public
+     * Get the component definition from the component id.
+     * @param componentId - component number or name used to identify the component descriptor
+     * @returns the component definition, throw an error if it doesn't exist
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.getComponent(StateComponentId)
+     * ```
+     */
+    getComponent<T>(componentId: number | string): ComponentDefinition<T>;
+    /**
+     * Get the component definition from the component id.
+     * @param componentId - component number or name used to identify the component descriptor
+     * @returns the component definition or null if its not founded
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.getComponent(StateComponentId)
+     * ```
+     */
+    getComponentOrNull<T>(componentId: number | string): ComponentDefinition<T> | null;
+    /**
+     * @public
+     * Get a iterator of entities that has all the component requested.
+     * @param components - a list of component definitions
+     * @returns An iterator of an array with the [entity, component1, component2, ...]
+     *
+     * Example:
+     * ```ts
+     * for (const [entity, meshRenderer, transform] of engine.getEntitiesWith(MeshRenderer, Transform)) {
+     *   // the properties of meshRenderer and transform are read only
+     * }
+     * ```
+     */
+    getEntitiesWith<T extends [ComponentDefinition<any>, ...ComponentDefinition<any>[]]>(...components: T): Iterable<[Entity, ...ReadonlyComponentSchema<T>]>;
+    /**
+     * @public
+     * @param deltaTime - deltaTime in seconds
+     */
+    update(deltaTime: number): Promise<void>;
+    /**
+     * @public
+     * Refer to the root of the scene, all Transforms without a parent are parenting with RootEntity.
+     */
+    readonly RootEntity: Entity;
+    /**
+     * @public
+     * The current player entity
+     */
+    readonly PlayerEntity: Entity;
+    /**
+     * @public
+     * Camera entity of current player.
+     */
+    readonly CameraEntity: Entity;
+    /**
+     * @alpha
+     * @param transport - transport which changes its onmessage to process CRDT messages
+     */
+    addTransport(transport: Transport): void;
+    /**
+     * @public
+     * Iterator of registered components
+     */
+    componentsIter(): Iterable<ComponentDefinition<unknown>>;
+    /**
+     * Seals the engine components. It is used to clearly define the scope of the
+     * components that will be available to this engine and to run optimizations.
+     */
+    seal(): void;
+}

package/dist-cjs/engine/types.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./component"), exports);

package/dist-cjs/index.d.ts

@@ -0,0 +1,22 @@
+export * from './engine';
+export * from './schemas';
+export * from './runtime/initialization';
+export * from './runtime/types';
+export * from './runtime/helpers';
+export { cyclicParentingChecker } from './systems/cyclicParentingChecker';
+export * from './systems/events';
+export * from './systems/raycast';
+export * from './systems/videoEvents';
+export * from './systems/async-task';
+export * from './engine/entity';
+export * from './components/types';
+import { MaterialComponentDefinitionExtended, MeshColliderComponentDefinitionExtended, MeshRendererComponentDefinitionExtended, TransformComponentExtended, AnimatorComponentDefinitionExtended } from './components/types';
+export declare const Transform: TransformComponentExtended;
+export declare const Animator: AnimatorComponentDefinitionExtended;
+export declare const Material: MaterialComponentDefinitionExtended;
+export declare const MeshRenderer: MeshRendererComponentDefinitionExtended;
+export declare const MeshCollider: MeshColliderComponentDefinitionExtended;
+export * from './components/generated/global.gen';
+export * from './components/generated/types.gen';
+export * from './serialization/crdt';
+export * from './composite';

package/dist-cjs/index.js

@@ -0,0 +1,58 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.MeshCollider = exports.MeshRenderer = exports.Material = exports.Animator = exports.Transform = exports.components = exports.cyclicParentingChecker = void 0;
+// The order of the following imports matters. Please do not auto-sort
+__exportStar(require("./engine"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./runtime/initialization"), exports);
+__exportStar(require("./runtime/types"), exports);
+__exportStar(require("./runtime/helpers"), exports);
+var cyclicParentingChecker_1 = require("./systems/cyclicParentingChecker");
+Object.defineProperty(exports, "cyclicParentingChecker", { enumerable: true, get: function () { return cyclicParentingChecker_1.cyclicParentingChecker; } });
+__exportStar(require("./systems/events"), exports);
+__exportStar(require("./systems/raycast"), exports);
+__exportStar(require("./systems/videoEvents"), exports);
+__exportStar(require("./systems/async-task"), exports);
+__exportStar(require("./engine/entity"), exports);
+__exportStar(require("./components/types"), exports);
+// @internal
+const components = __importStar(require("./components"));
+exports.components = components;
+const initialization_1 = require("./runtime/initialization");
+// export components for global engine
+exports.Transform = components.Transform(initialization_1.engine);
+exports.Animator = components.Animator(initialization_1.engine);
+exports.Material = components.Material(initialization_1.engine);
+exports.MeshRenderer = components.MeshRenderer(initialization_1.engine);
+exports.MeshCollider = components.MeshCollider(initialization_1.engine);
+// export components for global engine
+__exportStar(require("./components/generated/global.gen"), exports);
+__exportStar(require("./components/generated/types.gen"), exports);
+__exportStar(require("./serialization/crdt"), exports);
+__exportStar(require("./composite"), exports);

package/dist-cjs/runtime/crc.d.ts

@@ -0,0 +1 @@
+export declare function unsignedCRC32(data: Uint8Array, prev?: number): number;

package/dist-cjs/runtime/crc.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsignedCRC32 = void 0;
+const CRC_TABLE = new Int32Array([
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
+    0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
+    0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+    0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
+    0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
+    0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
+    0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
+    0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+    0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
+    0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
+    0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
+    0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
+    0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+    0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
+    0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+]);
+function _crc32(buf, previous) {
+    let crc = ~~previous ^ -1;
+    for (let n = 0; n < buf.length; n++) {
+        crc = CRC_TABLE[(crc ^ buf[n]) & 0xff] ^ (crc >>> 8);
+    }
+    return crc ^ -1;
+}
+function unsignedCRC32(data, prev = 0) {
+    return _crc32(data, prev) >>> 0;
+}
+exports.unsignedCRC32 = unsignedCRC32;

package/dist-cjs/runtime/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './tree';

package/dist-cjs/runtime/helpers/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tree"), exports);

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

@@ -0,0 +1,32 @@
+import { Entity } from '../../engine/entity';
+import { ComponentDefinition, IEngine } from '../../engine';
+/**
+ * Get an iterator of entities that follow a tree structure for a component
+ * @public
+ * @param engine - the engine running the entities
+ * @param entity - the root entity of the tree
+ * @param component - the parenting component to filter by
+ * @returns An iterator of an array as [entity, entity2, ...]
+ *
+ * Example:
+ * ```ts
+ * const TreeComponent = engine.defineComponent('custom::TreeComponent', {
+ *    label: Schemas.String,
+ *    parent: Schemas.Entity
+ * })
+ *
+ * for (const entity of getComponentEntityTree(engine, entity, TreeComponent)) {
+ *    // entity in the tree
+ * }
+ * ```
+ */
+export declare function getComponentEntityTree<T>(engine: IEngine, entity: Entity, component: ComponentDefinition<T & {
+    parent?: Entity;
+}>): Generator<Entity>;
+/**
+ * Remove all components of each entity in the tree made with Transform parenting
+ * @param engine - the engine running the entities
+ * @param firstEntity - the root entity of the tree
+ * @public
+ */
+export declare function removeEntityWithChildren(engine: IEngine, entity: Entity): void;

package/dist-cjs/runtime/helpers/tree.js

@@ -0,0 +1,77 @@
+"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.removeEntityWithChildren = exports.getComponentEntityTree = void 0;
+const components = __importStar(require("../../components"));
+function* genEntityTree(entity, entities) {
+    // This avoid infinite loop when there is a cyclic parenting
+    if (!entities.has(entity))
+        return;
+    entities.delete(entity);
+    for (const [_entity, value] of entities) {
+        if (value.parent === entity) {
+            yield* genEntityTree(_entity, entities);
+        }
+    }
+    yield entity;
+}
+/**
+ * Get an iterator of entities that follow a tree structure for a component
+ * @public
+ * @param engine - the engine running the entities
+ * @param entity - the root entity of the tree
+ * @param component - the parenting component to filter by
+ * @returns An iterator of an array as [entity, entity2, ...]
+ *
+ * Example:
+ * ```ts
+ * const TreeComponent = engine.defineComponent('custom::TreeComponent', {
+ *    label: Schemas.String,
+ *    parent: Schemas.Entity
+ * })
+ *
+ * for (const entity of getComponentEntityTree(engine, entity, TreeComponent)) {
+ *    // entity in the tree
+ * }
+ * ```
+ */
+function getComponentEntityTree(engine, entity, component) {
+    const entities = new Map(engine.getEntitiesWith(component));
+    return genEntityTree(entity, entities);
+}
+exports.getComponentEntityTree = getComponentEntityTree;
+/**
+ * Remove all components of each entity in the tree made with Transform parenting
+ * @param engine - the engine running the entities
+ * @param firstEntity - the root entity of the tree
+ * @public
+ */
+function removeEntityWithChildren(engine, entity) {
+    const Transform = components.Transform(engine);
+    for (const _entity of getComponentEntityTree(engine, entity, Transform)) {
+        engine.removeEntity(_entity);
+    }
+}
+exports.removeEntityWithChildren = removeEntityWithChildren;

package/dist-cjs/runtime/initialization/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @alpha * This file initialization is an alpha one. This is based on the old-ecs
+ * init and it'll be changing.
+ */
+import { IEngine } from '../../engine';
+import { Task } from '../../systems/async-task';
+import { PointerEventsSystem } from '../../systems/events';
+import { IInputSystem } from './../../engine/input';
+import { RaycastSystem } from '../../systems/raycast';
+import { VideoEventsSystem } from '../../systems/videoEvents';
+/**
+ * @public
+ * The engine is the part of the scene that sits in the middle and manages all of the other parts.
+ * It determines what entities are rendered and how players interact with them.
+ * It also coordinates what functions from systems are executed and when.
+ *
+ * @example
+ * import { engine } from '@dcl/sdk/ecs'
+ * const entity = engine.addEntity()
+ * engine.addSystem(someSystemFunction)
+ *
+ */
+export declare const engine: IEngine;
+/**
+ * @public
+ * Input system manager. Check for button events
+ * @example
+ * inputSystem.isTriggered: Returns true if an input action ocurred since the last tick.
+ * inputSystem.isPressed: Returns true if an input is currently being pressed down. It will return true on every tick until the button goes up again.
+ * inputSystem.getInputCommand: Returns an object with data about the input action.
+ */
+export declare const inputSystem: IInputSystem;
+export { IInputSystem };
+/**
+ * @public
+ * Register callback functions to a particular entity on input events.
+ */
+export declare const pointerEventsSystem: PointerEventsSystem;
+export { PointerEventsSystem };
+/**
+ * @public
+ * Register callback functions to a particular entity on raycast results.
+ */
+export declare const raycastSystem: RaycastSystem;
+export { RaycastSystem };
+/**
+ * @alpha
+ * @public
+ * Register callback functions to a particular entity on video events.
+ */
+export declare const videoEventsSystem: VideoEventsSystem;
+export { VideoEventsSystem };
+/**
+ * @public
+ * Runs an async function
+ */
+export declare const executeTask: (task: Task<unknown>) => void;
+/**
+ * @public
+ */
+export type { Task };

package/dist-cjs/runtime/initialization/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * @alpha * This file initialization is an alpha one. This is based on the old-ecs
+ * init and it'll be changing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTask = exports.videoEventsSystem = exports.raycastSystem = exports.pointerEventsSystem = exports.inputSystem = exports.engine = void 0;
+const engine_1 = require("../../engine");
+const async_task_1 = require("../../systems/async-task");
+const events_1 = require("../../systems/events");
+const input_1 = require("./../../engine/input");
+const raycast_1 = require("../../systems/raycast");
+const videoEvents_1 = require("../../systems/videoEvents");
+/**
+ * @public
+ * The engine is the part of the scene that sits in the middle and manages all of the other parts.
+ * It determines what entities are rendered and how players interact with them.
+ * It also coordinates what functions from systems are executed and when.
+ *
+ * @example
+ * import { engine } from '@dcl/sdk/ecs'
+ * const entity = engine.addEntity()
+ * engine.addSystem(someSystemFunction)
+ *
+ */
+exports.engine = (0, engine_1.Engine)();
+/**
+ * @public
+ * Input system manager. Check for button events
+ * @example
+ * inputSystem.isTriggered: Returns true if an input action ocurred since the last tick.
+ * inputSystem.isPressed: Returns true if an input is currently being pressed down. It will return true on every tick until the button goes up again.
+ * inputSystem.getInputCommand: Returns an object with data about the input action.
+ */
+exports.inputSystem = (0, input_1.createInputSystem)(exports.engine);
+/**
+ * @public
+ * Register callback functions to a particular entity on input events.
+ */
+exports.pointerEventsSystem = (0, events_1.createPointerEventsSystem)(exports.engine, exports.inputSystem);
+/**
+ * @public
+ * Register callback functions to a particular entity on raycast results.
+ */
+exports.raycastSystem = (0, raycast_1.createRaycastSystem)(exports.engine);
+/**
+ * @alpha
+ * @public
+ * Register callback functions to a particular entity on video events.
+ */
+exports.videoEventsSystem = (0, videoEvents_1.createVideoEventsSystem)(exports.engine);
+/**
+ * @public
+ * Runs an async function
+ */
+exports.executeTask = (0, async_task_1.createTaskSystem)(exports.engine);

package/dist-cjs/runtime/invariant.d.ts

@@ -0,0 +1,4 @@
+type K = unknown | Promise<unknown>;
+export declare const __DEV__: boolean;
+export declare function checkNotThenable<T extends K>(t: T, error: string): T;
+export {};

package/dist-cjs/runtime/invariant.js

@@ -0,0 +1,17 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNotThenable = exports.__DEV__ = void 0;
+exports.__DEV__ = (typeof DEBUG === 'boolean' && DEBUG) ||
+    (typeof process === 'object' &&
+        (process.env?.NODE_ENV !== 'production' || process.env?.NODE_ENV === 'development')) ||
+    false;
+function checkNotThenable(t, error) {
+    if (exports.__DEV__) {
+        if (t && typeof t === 'object' && typeof t.then === 'function') {
+            throw new Error(error);
+        }
+    }
+    return t;
+}
+exports.checkNotThenable = checkNotThenable;

package/dist-cjs/runtime/types.d.ts

@@ -0,0 +1,6 @@
+export type { SystemFn } from '../engine/systems';
+export type { TransportMessage, ReceiveMessage, Transport } from '../systems/crdt/types';
+export { TransformType, TransformComponent } from '../components/manual/Transform';
+export * from '../engine/component';
+export * from '../schemas/typing';
+export type { MapResult, Spec } from '../schemas/Map';

package/dist-cjs/runtime/types.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../engine/component"), exports);
+__exportStar(require("../schemas/typing"), exports);