@dcl/ecs 7.1.4-4601317654.commit-d2ae6e4 → 7.1.4-4608901735.commit-37cc11b

package/dist/composite/components.d.ts

@@ -5,7 +5,7 @@ import { IEngine, LastWriteWinElementSetComponentDefinition } from '../engine/ty
  * @deprecated composite is not being supported so far, please do not use this feature
  */
 export type CompositeRootType = {
-    id: string;
+    src: string;
     entities: {
         src: Entity;
         dest: Entity;

package/dist/composite/components.js

@@ -9,7 +9,7 @@ export function getCompositeRootComponent(engine) {
         return component;
     }
     return engine.defineComponent('composite::root', {
-        id: Schemas.String,
+        src: Schemas.String,
         entities: Schemas.Array(Schemas.Map({
             src: Schemas.Entity,
             dest: Schemas.Entity

package/dist/composite/index.d.ts

@@ -1,9 +1,9 @@
 import { IEngine } from '../engine';
 import { CompositeRootType, getCompositeRootComponent } from './components';
-import { CompositeProvider, EntityMappingMode, InstanceCompositeOptions } from './instance';
+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 };
+export type { CompositeDefinition, ComponentData, CompositeComponent, CompositeComponent_DataEntry, InstanceCompositeOptions, CompositeProvider, CompositeRootType, CompositeResource };
 export { EntityMappingMode };
 export { getCompositeRootComponent };
 /**
@@ -17,17 +17,19 @@ export type Composite = CompositeDefinition;
  */
 export declare namespace Composite {
     /** @public */
-    type Type = CompositeDefinition;
+    type Definition = CompositeDefinition;
+    /** @public */
+    type Resource = CompositeResource;
     /** @public */
     type Provider = CompositeProvider;
     /** @public */
-    function fromJson(object: any): Composite.Type;
+    function fromJson(object: any): Composite.Definition;
     /** @public */
-    function fromBinary(buffer: Uint8Array): Composite.Type;
+    function fromBinary(buffer: Uint8Array): Composite.Definition;
     /** @public */
-    function toJson(composite: Composite.Type): any;
+    function toJson(composite: Composite.Definition): any;
     /** @public */
-    function toBinary(composite: Composite.Type): Uint8Array;
+    function toBinary(composite: Composite.Definition): Uint8Array;
     /**
      * Instance a composite and returns its root entity
      * @param compositeData - state serialized by the CRDT protocol
@@ -36,5 +38,14 @@ export declare namespace Composite {
      *
      * @public
      */
-    function instance(engine: IEngine, compositeData: Composite.Type, compositeProvider: CompositeProvider, options?: InstanceCompositeOptions): void;
+    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/composite/index.js

@@ -1,5 +1,6 @@
 import { getCompositeRootComponent } from './components';
 import { EntityMappingMode, instanceComposite } from './instance';
+import { resolveComposite } from './path';
 import { CompositeDefinition } from './proto/gen/composite.gen';
 export { EntityMappingMode };
 export { getCompositeRootComponent };
@@ -41,4 +42,16 @@ export var Composite;
         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 resolveComposite(src, cwd);
+    }
+    Composite.resolveAndNormalizePath = resolveAndNormalizePath;
 })(Composite || (Composite = {}));

package/dist/composite/instance.d.ts

@@ -3,8 +3,16 @@ 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(id: string): CompositeDefinition | null;
+    getCompositeOrNull(src: string): CompositeResource | null;
 };
 /** @public */
 export declare enum EntityMappingMode {
@@ -22,5 +30,5 @@ export type InstanceCompositeOptions = {
         getCompositeEntity: (compositeEntity: Entity | number) => Entity;
     };
     rootEntity?: Entity;
-    alreadyRequestedId?: Set<string>;
+    alreadyRequestedSrc?: Set<string>;
 };

package/dist/composite/instance.js

@@ -3,6 +3,7 @@ import { componentNumberFromName } from '../components/component-number';
 import { Schemas } from '../schemas';
 import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
 import { getCompositeRootComponent } from './components';
+import * as path from './path';
 /** @public */
 /* @__PURE__ */
 export var EntityMappingMode;
@@ -77,9 +78,10 @@ export function getEntityMapping(engine, compositeEntity, mappedEntities, { enti
  * @internal
  */
 /* @__PURE__ */
-export function instanceComposite(engine, compositeData, compositeProvider, options) {
-    const { rootEntity, alreadyRequestedId: optionalAlreadyRequestedId, entityMapping } = options;
-    const alreadyRequestedId = optionalAlreadyRequestedId || new Set();
+export 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 = componentNumberFromName('core::Transform');
     const CompositeRootComponent = getCompositeRootComponent(engine);
     // Key => EntityNumber from the composite
@@ -97,19 +99,21 @@ export function instanceComposite(engine, compositeData, compositeProvider, opti
     // 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 = compositeData.components.find((item) => item.name === CompositeRootComponent.componentName);
+    const childrenComposite = compositeResource.composite.components.find((item) => item.name === CompositeRootComponent.componentName);
     if (childrenComposite) {
-        for (const [compositeEntity, childComposite] of childrenComposite.data) {
-            const compositeRoot = getComponentValue(CompositeRootComponent, childComposite);
-            const composite = compositeProvider.getCompositeOrNull(compositeRoot.id);
-            const targetEntity = getCompositeEntity(compositeEntity);
-            if (composite) {
-                if (alreadyRequestedId.has(compositeRoot.id) || compositeRoot.id === compositeData.id) {
-                    throw new Error(`Composite ${compositeRoot.id} has a recursive instanciation while try to instance ${compositeData.id}. Previous instances: ${alreadyRequestedId.toString()}`);
+        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, composite, compositeProvider, {
+                instanceComposite(engine, childCompositeResource, compositeProvider, {
                     rootEntity: targetEntity,
-                    alreadyRequestedId: new Set(alreadyRequestedId).add(compositeData.id),
+                    alreadyRequestedSrc: new Set(alreadyRequestedSrc).add(childCompositeResource.src),
                     entityMapping: entityMapping?.type === EntityMappingMode.EMM_NEXT_AVAILABLE ? entityMapping : undefined
                 });
             }
@@ -117,7 +121,7 @@ export function instanceComposite(engine, compositeData, compositeProvider, opti
     }
     // ## 3 ##
     // Then, we copy the all rest of the components (skipping the Composite ones)
-    for (const component of compositeData.components) {
+    for (const component of compositeResource.composite.components) {
         // We already instanced the composite
         if (component.name === CompositeRootComponent.componentName)
             continue;
@@ -152,6 +156,6 @@ export function instanceComposite(engine, compositeData, compositeProvider, opti
             dest: targetEntity
         });
     }
-    composite.id = compositeData.id;
+    composite.src = compositeResource.src;
     return compositeRootEntity;
 }

package/dist/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;

package/dist/composite/path.js

@@ -0,0 +1,148 @@
+const currentWorkingDir = '/';
+/**
+ * The functions `normalizeStringPosix`, `dirname` and `resolve`
+ * were extracted from package @browserify/path
+ */
+/* istanbul ignore next */
+function normalizeStringPosix(path, allowAboveRoot = false) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length)
+            code = path.charCodeAt(i);
+        else if (code === 47 /*/*/)
+            break;
+        else
+            code = 47; /*/*/
+        if (code === 47 /*/*/) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (lastSlash !== i - 1 && dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== 46 /*.*/ ||
+                    res.charCodeAt(res.length - 2) !== 46 /*.*/) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf('/');
+                        if (lastSlashIndex !== res.length - 1) {
+                            if (lastSlashIndex === -1) {
+                                res = '';
+                                lastSegmentLength = 0;
+                            }
+                            else {
+                                res = res.slice(0, lastSlashIndex);
+                                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+                            }
+                            lastSlash = i;
+                            dots = 0;
+                            continue;
+                        }
+                    }
+                    else if (res.length === 2 || res.length === 1) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    if (res.length > 0)
+                        res += '/..';
+                    else
+                        res = '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += '/' + path.slice(lastSlash + 1, i);
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === 46 /*.*/ && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+/* istanbul ignore next */
+export function resolve(...args) {
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        let path;
+        if (i >= 0)
+            path = args[i];
+        else {
+            if (cwd === undefined)
+                cwd = currentWorkingDir;
+            path = cwd;
+        }
+        // Skip empty entries
+        if (path.length === 0) {
+            continue;
+        }
+        resolvedPath = path + '/' + resolvedPath;
+        resolvedAbsolute = path.charCodeAt(0) === 47; /*/*/
+    }
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // Normalize the path
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+        if (resolvedPath.length > 0)
+            return '/' + resolvedPath;
+        else
+            return '/';
+    }
+    else if (resolvedPath.length > 0) {
+        return resolvedPath;
+    }
+    else {
+        return '.';
+    }
+}
+/* istanbul ignore next */
+export function dirname(path) {
+    if (path.length === 0)
+        return '.';
+    let code = path.charCodeAt(0);
+    const hasRoot = code === 47; /*/*/
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+        code = path.charCodeAt(i);
+        if (code === 47 /*/*/) {
+            if (!matchedSlash) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            // We saw the first non-path separator
+            matchedSlash = false;
+        }
+    }
+    if (end === -1)
+        return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1)
+        return '//';
+    return path.slice(0, end);
+}
+export function resolveComposite(path, cwd) {
+    const absolutePath = path.startsWith('.') ? resolve(cwd, path) : resolve(path);
+    return absolutePath.substring(1);
+}

package/dist/composite/proto/gen/composite.gen.d.ts

@@ -29,6 +29,6 @@ export interface CompositeComponent_DataEntry {
  * @public
  */
 export interface CompositeDefinition {
-    id: string;
+    version: number;
     components: CompositeComponent[];
 }

package/dist/composite/proto/gen/composite.gen.js

@@ -184,7 +184,7 @@ export const CompositeComponent_DataEntry = {
     },
 };
 function createBaseCompositeDefinition() {
-    return { id: "", components: [] };
+    return { version: 0, components: [] };
 }
 /**
  * @public
@@ -194,8 +194,8 @@ function createBaseCompositeDefinition() {
  */
 export const CompositeDefinition = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.id !== "") {
-            writer.uint32(10).string(message.id);
+        if (message.version !== 0) {
+            writer.uint32(8).int32(message.version);
         }
         for (const v of message.components) {
             CompositeComponent.encode(v, writer.uint32(18).fork()).ldelim();
@@ -210,7 +210,7 @@ export const CompositeDefinition = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    message.id = reader.string();
+                    message.version = reader.int32();
                     break;
                 case 2:
                     message.components.push(CompositeComponent.decode(reader, reader.uint32()));
@@ -224,7 +224,7 @@ export const CompositeDefinition = {
     },
     fromJSON(object) {
         return {
-            id: isSet(object.id) ? String(object.id) : "",
+            version: isSet(object.version) ? Number(object.version) : 0,
             components: Array.isArray(object?.components)
                 ? object.components.map((e) => CompositeComponent.fromJSON(e))
                 : [],
@@ -232,7 +232,7 @@ export const CompositeDefinition = {
     },
     toJSON(message) {
         const obj = {};
-        message.id !== undefined && (obj.id = message.id);
+        message.version !== undefined && (obj.version = Math.round(message.version));
         if (message.components) {
             obj.components = message.components.map((e) => e ? CompositeComponent.toJSON(e) : undefined);
         }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.1.4-4601317654.commit-d2ae6e4",
+  "version": "7.1.4-4608901735.commit-37cc11b",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "dependencies": {
-    "@dcl/js-runtime": "7.1.4-4601317654.commit-d2ae6e4"
+    "@dcl/js-runtime": "7.1.4-4608901735.commit-37cc11b"
   },
   "devDependencies": {
     "ts-proto": "^1.122.0"
@@ -34,5 +34,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "d2ae6e4e772dd0c26524700bdb34e0272baa0fe6"
+  "commit": "37cc11b3938c4420eaeb2fb38af3625e3dec7951"
 }