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

package/dist-cjs/components/generated/types.gen.d.ts

@@ -0,0 +1,9 @@
+export type { Position as PBPosition, Vector2 as PBVector2, Vector3 as PBVector3 } from './pb/decentraland/common/vectors.gen';
+export type { Color3 as PBColor3, Color4 as PBColor4 } from './pb/decentraland/common/colors.gen';
+export * from './pb/decentraland/sdk/components/common/camera_type.gen';
+export * from './pb/decentraland/sdk/components/common/input_action.gen';
+export * from './pb/decentraland/sdk/components/common/loading_state.gen';
+export * from './pb/decentraland/sdk/components/common/raycast_hit.gen';
+export * from './pb/decentraland/sdk/components/common/texts.gen';
+export * from './pb/decentraland/common/border_rect.gen';
+export * from './pb/decentraland/common/texture.gen';

package/dist-cjs/components/generated/types.gen.js

@@ -0,0 +1,30 @@
+"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("./pb/decentraland/sdk/components/common/camera_type.gen"), exports);
+// export { PbCameraType }
+__exportStar(require("./pb/decentraland/sdk/components/common/input_action.gen"), exports);
+// export { PbInputAction }
+__exportStar(require("./pb/decentraland/sdk/components/common/loading_state.gen"), exports);
+// export { PbLoadingState }
+__exportStar(require("./pb/decentraland/sdk/components/common/raycast_hit.gen"), exports);
+// export { PbRaycastHit }
+__exportStar(require("./pb/decentraland/sdk/components/common/texts.gen"), exports);
+// export { PbTexts }
+__exportStar(require("./pb/decentraland/common/border_rect.gen"), exports);
+// export { PbBorderRect }
+__exportStar(require("./pb/decentraland/common/texture.gen"), exports);
+// export { PbTexture }

package/dist-cjs/components/index.d.ts

@@ -0,0 +1,14 @@
+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 { LwwComponentGetter, GSetComponentGetter } from './generated/index.gen';
+import { TransformComponentExtended } from './manual/Transform';
+export * from './generated/index.gen';
+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-cjs/components/index.js

@@ -0,0 +1,38 @@
+"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 });
+exports.MeshCollider = exports.MeshRenderer = exports.Animator = exports.Material = exports.Transform = void 0;
+const Animator_1 = require("./extended/Animator");
+const Material_1 = require("./extended/Material");
+const MeshCollider_1 = require("./extended/MeshCollider");
+const MeshRenderer_1 = require("./extended/MeshRenderer");
+const Transform_1 = require("./manual/Transform");
+__exportStar(require("./generated/index.gen"), exports);
+/* @__PURE__ */
+const Transform = (engine) => (0, Transform_1.defineTransformComponent)(engine);
+exports.Transform = Transform;
+/* @__PURE__ */
+const Material = (engine) => (0, Material_1.defineMaterialComponent)(engine);
+exports.Material = Material;
+/* @__PURE__ */
+const Animator = (engine) => (0, Animator_1.defineAnimatorComponent)(engine);
+exports.Animator = Animator;
+/* @__PURE__ */
+const MeshRenderer = (engine) => (0, MeshRenderer_1.defineMeshRendererComponent)(engine);
+exports.MeshRenderer = MeshRenderer;
+/* @__PURE__ */
+const MeshCollider = (engine) => (0, MeshCollider_1.defineMeshColliderComponent)(engine);
+exports.MeshCollider = MeshCollider;

package/dist-cjs/components/manual/Transform.d.ts

@@ -0,0 +1,40 @@
+import { LastWriteWinElementSetComponentDefinition, IEngine } from '../../engine';
+import { Entity } from '../../engine/entity';
+/**
+ * @public
+ */
+export type TransformComponent = LastWriteWinElementSetComponentDefinition<TransformType>;
+/**
+ * @public
+ */
+export interface TransformComponentExtended extends TransformComponent {
+    create(entity: Entity, val?: TransformTypeWithOptionals): TransformType;
+    createOrReplace(entity: Entity, val?: TransformTypeWithOptionals): TransformType;
+}
+/**
+ * @public
+ */
+export type TransformType = {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    parent?: Entity;
+};
+/**
+ * @public
+ */
+export type TransformTypeWithOptionals = Partial<TransformType>;
+export declare function defineTransformComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): TransformComponentExtended;

package/dist-cjs/components/manual/Transform.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTransformComponent = exports.TransformSchema = exports.TRANSFORM_LENGTH = exports.COMPONENT_ID = void 0;
+/**
+ * @internal
+ */
+exports.COMPONENT_ID = 1;
+/** @internal */
+exports.TRANSFORM_LENGTH = 44;
+/** @internal */
+exports.TransformSchema = {
+    serialize(value, builder) {
+        const ptr = builder.incrementWriteOffset(exports.TRANSFORM_LENGTH);
+        builder.setFloat32(ptr, value.position.x);
+        builder.setFloat32(ptr + 4, value.position.y);
+        builder.setFloat32(ptr + 8, value.position.z);
+        builder.setFloat32(ptr + 12, value.rotation.x);
+        builder.setFloat32(ptr + 16, value.rotation.y);
+        builder.setFloat32(ptr + 20, value.rotation.z);
+        builder.setFloat32(ptr + 24, value.rotation.w);
+        builder.setFloat32(ptr + 28, value.scale.x);
+        builder.setFloat32(ptr + 32, value.scale.y);
+        builder.setFloat32(ptr + 36, value.scale.z);
+        builder.setUint32(ptr + 40, value.parent || 0);
+    },
+    deserialize(reader) {
+        const ptr = reader.incrementReadOffset(exports.TRANSFORM_LENGTH);
+        return {
+            position: {
+                x: reader.getFloat32(ptr),
+                y: reader.getFloat32(ptr + 4),
+                z: reader.getFloat32(ptr + 8)
+            },
+            rotation: {
+                x: reader.getFloat32(ptr + 12),
+                y: reader.getFloat32(ptr + 16),
+                z: reader.getFloat32(ptr + 20),
+                w: reader.getFloat32(ptr + 24)
+            },
+            scale: {
+                x: reader.getFloat32(ptr + 28),
+                y: reader.getFloat32(ptr + 32),
+                z: reader.getFloat32(ptr + 36)
+            },
+            parent: reader.getUint32(ptr + 40)
+        };
+    },
+    create() {
+        return {
+            position: { x: 0, y: 0, z: 0 },
+            scale: { x: 1, y: 1, z: 1 },
+            rotation: { x: 0, y: 0, z: 0, w: 1 },
+            parent: 0
+        };
+    },
+    extend(value) {
+        return {
+            position: { x: 0, y: 0, z: 0 },
+            scale: { x: 1, y: 1, z: 1 },
+            rotation: { x: 0, y: 0, z: 0, w: 1 },
+            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'
+    }
+};
+function defineTransformComponent(engine) {
+    const transformDef = engine.defineComponentFromSchema('core::Transform', exports.TransformSchema);
+    return {
+        ...transformDef,
+        create(entity, val) {
+            return transformDef.create(entity, exports.TransformSchema.extend(val));
+        },
+        createOrReplace(entity, val) {
+            return transformDef.createOrReplace(entity, exports.TransformSchema.extend(val));
+        }
+    };
+}
+exports.defineTransformComponent = defineTransformComponent;

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

@@ -0,0 +1,5 @@
+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 './manual/Transform';

package/dist-cjs/components/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/composite/components.d.ts

@@ -0,0 +1,18 @@
+import { Entity } from '../engine';
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../engine/types';
+/**
+ * @public
+ * @deprecated composite is not being supported so far, please do not use this feature
+ */
+export type CompositeRootType = {
+    src: string;
+    entities: {
+        src: Entity;
+        dest: Entity;
+    }[];
+};
+/**
+ * @public
+ * @deprecated composite is not being supported so far, please do not use this feature
+ */
+export declare function getCompositeRootComponent(engine: IEngine): LastWriteWinElementSetComponentDefinition<CompositeRootType>;

package/dist-cjs/composite/components.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositeRootComponent = void 0;
+const schemas_1 = require("../schemas");
+/**
+ * @public
+ * @deprecated composite is not being supported so far, please do not use this feature
+ */
+function getCompositeRootComponent(engine) {
+    const component = engine.getComponentOrNull('composite::root');
+    if (component) {
+        return component;
+    }
+    return engine.defineComponent('composite::root', {
+        src: schemas_1.Schemas.String,
+        entities: schemas_1.Schemas.Array(schemas_1.Schemas.Map({
+            src: schemas_1.Schemas.Entity,
+            dest: schemas_1.Schemas.Entity
+        }))
+    });
+}
+exports.getCompositeRootComponent = getCompositeRootComponent;

package/dist-cjs/composite/index.d.ts

@@ -0,0 +1,51 @@
+import { IEngine } from '../engine';
+import { CompositeRootType, getCompositeRootComponent } from './components';
+import { CompositeProvider, CompositeResource, EntityMappingMode, InstanceCompositeOptions } from './instance';
+import type { ComponentData, CompositeComponent, CompositeComponent_DataEntry } from './proto/gen/composite.gen';
+import { CompositeDefinition } from './proto/gen/composite.gen';
+export type { CompositeDefinition, ComponentData, CompositeComponent, CompositeComponent_DataEntry, InstanceCompositeOptions, CompositeProvider, CompositeRootType, CompositeResource };
+export { EntityMappingMode };
+export { getCompositeRootComponent };
+/**
+ * @public
+ * @deprecated composite is not being supported so far, please do not use this feature
+ */
+export type Composite = CompositeDefinition;
+/**
+ * @public
+ * @deprecated composite is not being supported so far, please do not use this feature
+ */
+export declare namespace Composite {
+    /** @public */
+    type Definition = CompositeDefinition;
+    /** @public */
+    type Resource = CompositeResource;
+    /** @public */
+    type Provider = CompositeProvider;
+    /** @public */
+    function fromJson(object: any): Composite.Definition;
+    /** @public */
+    function fromBinary(buffer: Uint8Array): Composite.Definition;
+    /** @public */
+    function toJson(composite: Composite.Definition): any;
+    /** @public */
+    function toBinary(composite: Composite.Definition): Uint8Array;
+    /**
+     * Instance a composite and returns its root entity
+     * @param compositeData - state serialized by the CRDT protocol
+     * @param getNextAvailableEntity - function that gives unused entities
+     * @param rootEntity - (optional) suggested mapped rootEntity for the composite
+     *
+     * @public
+     */
+    function instance(engine: IEngine, compositeData: Composite.Resource, compositeProvider: CompositeProvider, options?: InstanceCompositeOptions): void;
+    /**
+     * Resolve and normalize a composite path
+     * @param src - the source path
+     * @param cwd - the directory from the resolve should start to resolve
+     *
+     * @returns the absolute resolved path without slash at the beginning
+     * @public
+     */
+    function resolveAndNormalizePath(src: string, cwd?: string): string;
+}

package/dist-cjs/composite/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composite = exports.getCompositeRootComponent = exports.EntityMappingMode = void 0;
+const components_1 = require("./components");
+Object.defineProperty(exports, "getCompositeRootComponent", { enumerable: true, get: function () { return components_1.getCompositeRootComponent; } });
+const instance_1 = require("./instance");
+Object.defineProperty(exports, "EntityMappingMode", { enumerable: true, get: function () { return instance_1.EntityMappingMode; } });
+const path_1 = require("./path");
+const composite_gen_1 = require("./proto/gen/composite.gen");
+/**
+ * @public
+ * @deprecated composite is not being supported so far, please do not use this feature
+ */
+var Composite;
+(function (Composite) {
+    /** @public */
+    function fromJson(object) {
+        return composite_gen_1.CompositeDefinition.fromJSON(object);
+    }
+    Composite.fromJson = fromJson;
+    /** @public */
+    function fromBinary(buffer) {
+        return composite_gen_1.CompositeDefinition.decode(buffer);
+    }
+    Composite.fromBinary = fromBinary;
+    /** @public */
+    function toJson(composite) {
+        return composite_gen_1.CompositeDefinition.toJSON(composite);
+    }
+    Composite.toJson = toJson;
+    /** @public */
+    function toBinary(composite) {
+        return composite_gen_1.CompositeDefinition.encode(composite).finish();
+    }
+    Composite.toBinary = toBinary;
+    /**
+     * Instance a composite and returns its root entity
+     * @param compositeData - state serialized by the CRDT protocol
+     * @param getNextAvailableEntity - function that gives unused entities
+     * @param rootEntity - (optional) suggested mapped rootEntity for the composite
+     *
+     * @public
+     */
+    /*#__PURE__*/ function instance(engine, compositeData, compositeProvider, options = {}) {
+        (0, instance_1.instanceComposite)(engine, compositeData, compositeProvider, options);
+    }
+    Composite.instance = instance;
+    /**
+     * Resolve and normalize a composite path
+     * @param src - the source path
+     * @param cwd - the directory from the resolve should start to resolve
+     *
+     * @returns the absolute resolved path without slash at the beginning
+     * @public
+     */
+    /*#__PURE__*/ function resolveAndNormalizePath(src, cwd = '/') {
+        return (0, path_1.resolveComposite)(src, cwd);
+    }
+    Composite.resolveAndNormalizePath = resolveAndNormalizePath;
+})(Composite = exports.Composite || (exports.Composite = {}));

package/dist-cjs/composite/instance.d.ts

@@ -0,0 +1,34 @@
+import { Entity } from '../engine/entity';
+import { CompositeDefinition } from './proto/gen/composite.gen';
+/**
+ * @public
+ */
+export type CompositeResource = {
+    src: string;
+    composite: CompositeDefinition;
+};
+/**
+ * @param src - the source path of the composite
+ * @public
+ */
+export type CompositeProvider = {
+    getCompositeOrNull(src: string): CompositeResource | null;
+};
+/** @public */
+export declare enum EntityMappingMode {
+    EMM_NONE = 0,
+    EMM_NEXT_AVAILABLE = 1,
+    EMM_DIRECT_MAPPING = 2
+}
+/** @public  */
+export type InstanceCompositeOptions = {
+    entityMapping?: {
+        type: EntityMappingMode.EMM_NEXT_AVAILABLE;
+        getNextAvailableEntity: () => Entity | null;
+    } | {
+        type: EntityMappingMode.EMM_DIRECT_MAPPING;
+        getCompositeEntity: (compositeEntity: Entity | number) => Entity;
+    };
+    rootEntity?: Entity;
+    alreadyRequestedSrc?: Set<string>;
+};

package/dist-cjs/composite/instance.js

@@ -0,0 +1,201 @@
+"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.instanceComposite = exports.getEntityMapping = exports.getComponentDefinition = exports.getComponentValue = exports.EntityMappingMode = void 0;
+const components_1 = require("../components");
+const component_number_1 = require("../components/component-number");
+const schemas_1 = require("../schemas");
+const ByteBuffer_1 = require("../serialization/ByteBuffer");
+const components_2 = require("./components");
+const path = __importStar(require("./path"));
+/** @public */
+/* @__PURE__ */
+var EntityMappingMode;
+(function (EntityMappingMode) {
+    EntityMappingMode[EntityMappingMode["EMM_NONE"] = 0] = "EMM_NONE";
+    EntityMappingMode[EntityMappingMode["EMM_NEXT_AVAILABLE"] = 1] = "EMM_NEXT_AVAILABLE";
+    EntityMappingMode[EntityMappingMode["EMM_DIRECT_MAPPING"] = 2] = "EMM_DIRECT_MAPPING";
+})(EntityMappingMode = exports.EntityMappingMode || (exports.EntityMappingMode = {}));
+/**
+ * Return the component value from composite data
+ * @internal
+ */
+function getComponentValue(componentDefinition, component) {
+    if (component.data?.$case === 'json') {
+        return component.data.json;
+    }
+    else {
+        return componentDefinition.schema.deserialize(new ByteBuffer_1.ReadWriteByteBuffer(component.data?.binary));
+    }
+}
+exports.getComponentValue = getComponentValue;
+/**
+ * Return the component definition from composite info
+ * @internal
+ */
+function getComponentDefinition(engine, component) {
+    const existingComponentDefinition = engine.getComponentOrNull(component.name);
+    if (!existingComponentDefinition) {
+        if (component.name.startsWith('core::')) {
+            if (component.name in components_1.componentDefinitionByName) {
+                return components_1.componentDefinitionByName[component.name](engine);
+            }
+            else {
+                throw new Error(`The core component ${component.name} was not found.`);
+            }
+        }
+        else if (component.jsonSchema) {
+            return engine.defineComponentFromSchema(component.name, schemas_1.Schemas.fromJson(component.jsonSchema));
+        }
+        else {
+            throw new Error(`${component.name} is not defined and there is no schema to define it.`);
+        }
+    }
+    else {
+        return existingComponentDefinition;
+    }
+}
+exports.getComponentDefinition = getComponentDefinition;
+/**
+ * Return the entity mapping or fail if there is no more
+ * @internal
+ */
+function getEntityMapping(engine, compositeEntity, mappedEntities, { entityMapping }) {
+    const existingEntity = mappedEntities.get(compositeEntity);
+    if (existingEntity) {
+        return existingEntity;
+    }
+    if (entityMapping?.type === EntityMappingMode.EMM_DIRECT_MAPPING) {
+        const entity = entityMapping.getCompositeEntity(compositeEntity);
+        mappedEntities.set(compositeEntity, entity);
+        return entity;
+    }
+    // This function in runtime can be just `engine.addEntity()`
+    const newEntity = entityMapping?.type === EntityMappingMode.EMM_NEXT_AVAILABLE
+        ? entityMapping.getNextAvailableEntity()
+        : engine.addEntity();
+    if (newEntity === null) {
+        throw new Error('There is no more entities to allocate');
+    }
+    mappedEntities.set(compositeEntity, newEntity);
+    return newEntity;
+}
+exports.getEntityMapping = getEntityMapping;
+/**
+ * @internal
+ */
+/* @__PURE__ */
+function instanceComposite(engine, compositeResource, compositeProvider, options) {
+    const { rootEntity, alreadyRequestedSrc: optionalAlreadyRequestedSrc, entityMapping } = options;
+    const alreadyRequestedSrc = optionalAlreadyRequestedSrc || new Set();
+    const compositeDirectoryPath = path.dirname(path.resolve(compositeResource.src));
+    const TransformComponentNumber = (0, component_number_1.componentNumberFromName)('core::Transform');
+    const CompositeRootComponent = (0, components_2.getCompositeRootComponent)(engine);
+    // Key => EntityNumber from the composite
+    // Value => EntityNumber in current engine
+    const mappedEntities = new Map();
+    const getCompositeEntity = (compositeEntity) => getEntityMapping(engine, compositeEntity, mappedEntities, options);
+    // ## 1 ##
+    // First entity that I want to map, the root entity from the composite to the target entity in the engine
+    // If there is no `rootEntity` passed, we assign one from `getNextAvailableEntity`
+    const compositeRootEntity = rootEntity ?? getCompositeEntity(0);
+    if (rootEntity) {
+        mappedEntities.set(0, rootEntity);
+    }
+    // ## 2 ##
+    // If there are more composite inside this one, we instance first.
+    // => This is not only a copy, we need to instance. Otherwise, we'd be missing that branches
+    // => TODO: in the future, the instanciation is first, then the overides (to parameterize Composite, e.g. house with different wall colors)
+    const childrenComposite = compositeResource.composite.components.find((item) => item.name === CompositeRootComponent.componentName);
+    if (childrenComposite) {
+        for (const [childCompositeEntity, compositeRawData] of childrenComposite.data) {
+            const childComposite = getComponentValue(CompositeRootComponent, compositeRawData);
+            const childCompositePath = path.resolveComposite(childComposite.src, compositeDirectoryPath);
+            const childCompositeResource = compositeProvider.getCompositeOrNull(childCompositePath);
+            const targetEntity = getCompositeEntity(childCompositeEntity);
+            if (childCompositeResource) {
+                if (alreadyRequestedSrc.has(childCompositeResource.src) ||
+                    childCompositeResource.src === compositeResource.src) {
+                    throw new Error(`Composite ${compositeResource.src} has a recursive instanciation while try to instance ${childCompositeResource.src}. Previous instances: ${alreadyRequestedSrc.toString()}`);
+                }
+                instanceComposite(engine, childCompositeResource, compositeProvider, {
+                    rootEntity: targetEntity,
+                    alreadyRequestedSrc: new Set(alreadyRequestedSrc).add(childCompositeResource.src),
+                    entityMapping: entityMapping?.type === EntityMappingMode.EMM_NEXT_AVAILABLE ? entityMapping : undefined
+                });
+            }
+        }
+    }
+    // ## 3 ##
+    // Then, we copy the all rest of the components (skipping the Composite ones)
+    for (const component of compositeResource.composite.components) {
+        // We already instanced the composite
+        if (component.name === CompositeRootComponent.componentName)
+            continue;
+        // ## 3a ##
+        // We find the component definition
+        const componentDefinition = getComponentDefinition(engine, component);
+        // ## 3b ##
+        // Iterating over all the entities with this component and create the replica
+        for (const [entity, compositeComponentValue] of component.data) {
+            const componentValueDeserialized = getComponentValue(componentDefinition, compositeComponentValue);
+            const targetEntity = getCompositeEntity(entity);
+            const componentValue = componentDefinition.create(targetEntity, componentValueDeserialized);
+            // ## 3c ##
+            // All entities referenced in the composite probably has a different resolved EntityNumber
+            // We'll know with the mappedEntityes
+            if (componentDefinition.componentId === TransformComponentNumber) {
+                const transform = componentValue;
+                if (transform.parent) {
+                    transform.parent = getCompositeEntity(transform.parent);
+                }
+                else {
+                    transform.parent = getCompositeEntity(0);
+                }
+                // TODO: is it going to be necessary to remap assets? e.g. src param from AudioSource and GltfContainer
+            }
+            else {
+                schemas_1.Schemas.mutateNestedValues(componentDefinition.schema.jsonSchema, componentValue, (value, valueType) => {
+                    if (valueType.serializationType === 'entity') {
+                        return { changed: true, value: getCompositeEntity(value) };
+                    }
+                    else {
+                        return { changed: false };
+                    }
+                });
+            }
+        }
+    }
+    const composite = CompositeRootComponent.getMutableOrNull(compositeRootEntity) || CompositeRootComponent.create(compositeRootEntity);
+    for (const [entitySource, targetEntity] of mappedEntities) {
+        composite.entities.push({
+            src: entitySource,
+            dest: targetEntity
+        });
+    }
+    composite.src = compositeResource.src;
+    return compositeRootEntity;
+}
+exports.instanceComposite = instanceComposite;

package/dist-cjs/composite/path.d.ts

@@ -0,0 +1,3 @@
+export declare function resolve(...args: string[]): string;
+export declare function dirname(path: string): string;
+export declare function resolveComposite(path: string, cwd: string): string;