@dcl/ecs 7.1.2 → 7.1.3-4448471926.commit-264de76

package/dist/composite/instance.js

@@ -1,11 +1,51 @@
 import { componentDefinitionByName } from '../components';
 import { componentNumberFromName } from '../components/component-number';
 import { Schemas } from '../schemas';
+import { ReadWriteByteBuffer } from '../serialization/ByteBuffer';
 import { getCompositeRootComponent } from './components';
+/**
+ * Return the component value from composite data
+ * @internal
+ */
+export function getComponentValue(componentDefinition, component) {
+    if (component.data?.$case === 'json') {
+        return component.data.json;
+    }
+    else {
+        return componentDefinition.schema.deserialize(new ReadWriteByteBuffer(component.data?.binary));
+    }
+}
+/**
+ * Return the component definition from composite info
+ * @internal
+ */
+export function getComponentDefinition(engine, component) {
+    const existingComponentDefinition = engine.getComponentOrNull(component.name);
+    if (!existingComponentDefinition) {
+        if (component.jsonSchema) {
+            return engine.defineComponentFromSchema(component.name, Schemas.fromJson(component.jsonSchema));
+        }
+        else if (component.name.startsWith('core::')) {
+            if (component.name in componentDefinitionByName) {
+                return componentDefinitionByName[component.name](engine);
+            }
+            else {
+                throw new Error(`The core component ${component.name} was not found.`);
+            }
+        }
+        else {
+            throw new Error(`${component.name} is not defined and there is no schema to define it.`);
+        }
+    }
+    else {
+        return existingComponentDefinition;
+    }
+}
 /**
  * Return the entity mapping or fail if there is no more
+ * @internal
  */
-function getEntityMapping(compositeEntity, mappedEntities, getNextAvailableEntity) {
+export function getEntityMapping(compositeEntity, mappedEntities, getNextAvailableEntity) {
     const existingEntity = mappedEntities.get(compositeEntity);
     if (existingEntity) {
         return existingEntity;
@@ -50,7 +90,7 @@ export function instanceComposite(engine, compositeData, getNextAvailableEntity,
     const childrenComposite = compositeData.components.find((item) => item.name === CompositeRootComponent.componentName);
     if (childrenComposite) {
         for (const [entity, childComposite] of childrenComposite.data) {
-            const compositeRoot = childComposite;
+            const compositeRoot = getComponentValue(CompositeRootComponent, childComposite);
             const composite = compositeProvider.getCompositeOrNull(compositeRoot.id);
             if (composite) {
                 if (alreadyRequestedId.has(compositeRoot.id) || compositeRoot.id === compositeData.id) {
@@ -68,32 +108,13 @@ export function instanceComposite(engine, compositeData, getNextAvailableEntity,
             continue;
         // ## 3a ##
         // We find the component definition
-        let componentDefinition;
-        const existingComponentDefinition = engine.getComponentOrNull(component.name);
-        if (!existingComponentDefinition) {
-            if (component.schema) {
-                componentDefinition = engine.defineComponentFromSchema(component.name, Schemas.fromJson(component.schema));
-            }
-            else if (component.name.startsWith('core::')) {
-                if (component.name in componentDefinitionByName) {
-                    componentDefinition = componentDefinitionByName[component.name](engine);
-                }
-                else {
-                    throw new Error(`The core component ${component.name} was not found.`);
-                }
-            }
-            else {
-                throw new Error(`${component.name} is not defined and there is no schema to define it.`);
-            }
-        }
-        else {
-            componentDefinition = existingComponentDefinition;
-        }
+        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, compositeComponentValue);
+            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

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

@@ -0,0 +1,34 @@
+/**
+ * @public
+ */
+export interface ComponentData {
+    data?: {
+        $case: "json";
+        json: any | undefined;
+    } | {
+        $case: "binary";
+        binary: Uint8Array;
+    };
+}
+/**
+ * @public
+ */
+export interface CompositeComponent {
+    name: string;
+    jsonSchema: any | undefined;
+    data: Map<number, ComponentData>;
+}
+/**
+ * @public
+ */
+export interface CompositeComponent_DataEntry {
+    key: number;
+    value: ComponentData | undefined;
+}
+/**
+ * @public
+ */
+export interface Composite {
+    id: string;
+    components: CompositeComponent[];
+}

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

@@ -0,0 +1,290 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Value } from "./google/protobuf/struct.gen";
+const protobufPackageSarasa = "";
+function createBaseComponentData() {
+    return { data: undefined };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const ComponentData = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.data?.$case === "json") {
+            Value.encode(Value.wrap(message.data.json), writer.uint32(10).fork()).ldelim();
+        }
+        if (message.data?.$case === "binary") {
+            writer.uint32(18).bytes(message.data.binary);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseComponentData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.data = { $case: "json", json: Value.unwrap(Value.decode(reader, reader.uint32())) };
+                    break;
+                case 2:
+                    message.data = { $case: "binary", binary: reader.bytes() };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            data: isSet(object.json)
+                ? { $case: "json", json: object.json }
+                : isSet(object.binary)
+                    ? { $case: "binary", binary: bytesFromBase64(object.binary) }
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.data?.$case === "json" && (obj.json = message.data?.json);
+        message.data?.$case === "binary" &&
+            (obj.binary = message.data?.binary !== undefined ? base64FromBytes(message.data?.binary) : undefined);
+        return obj;
+    },
+};
+function createBaseCompositeComponent() {
+    return { name: "", jsonSchema: undefined, data: new Map() };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const CompositeComponent = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.jsonSchema !== undefined) {
+            Value.encode(Value.wrap(message.jsonSchema), writer.uint32(18).fork()).ldelim();
+        }
+        message.data.forEach((value, key) => {
+            CompositeComponent_DataEntry.encode({ key: key, value }, writer.uint32(26).fork()).ldelim();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCompositeComponent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.jsonSchema = Value.unwrap(Value.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    const entry3 = CompositeComponent_DataEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.data.set(entry3.key, entry3.value);
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? String(object.name) : "",
+            jsonSchema: isSet(object?.jsonSchema) ? object.jsonSchema : undefined,
+            data: isObject(object.data)
+                ? Object.entries(object.data).reduce((acc, [key, value]) => {
+                    acc.set(Number(key), ComponentData.fromJSON(value));
+                    return acc;
+                }, new Map())
+                : new Map(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.name !== undefined && (obj.name = message.name);
+        message.jsonSchema !== undefined && (obj.jsonSchema = message.jsonSchema);
+        obj.data = {};
+        if (message.data) {
+            message.data.forEach((v, k) => {
+                obj.data[k] = ComponentData.toJSON(v);
+            });
+        }
+        return obj;
+    },
+};
+function createBaseCompositeComponent_DataEntry() {
+    return { key: 0, value: undefined };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const CompositeComponent_DataEntry = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.key !== 0) {
+            writer.uint32(8).int32(message.key);
+        }
+        if (message.value !== undefined) {
+            ComponentData.encode(message.value, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCompositeComponent_DataEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.int32();
+                    break;
+                case 2:
+                    message.value = ComponentData.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? Number(object.key) : 0,
+            value: isSet(object.value) ? ComponentData.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined && (obj.key = Math.round(message.key));
+        message.value !== undefined && (obj.value = message.value ? ComponentData.toJSON(message.value) : undefined);
+        return obj;
+    },
+};
+function createBaseComposite() {
+    return { id: "", components: [] };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const Composite = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        for (const v of message.components) {
+            CompositeComponent.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseComposite();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                case 2:
+                    message.components.push(CompositeComponent.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            id: isSet(object.id) ? String(object.id) : "",
+            components: Array.isArray(object?.components)
+                ? object.components.map((e) => CompositeComponent.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.id !== undefined && (obj.id = message.id);
+        if (message.components) {
+            obj.components = message.components.map((e) => e ? CompositeComponent.toJSON(e) : undefined);
+        }
+        else {
+            obj.components = [];
+        }
+        return obj;
+    },
+};
+var tsProtoGlobalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function bytesFromBase64(b64) {
+    if (tsProtoGlobalThis.Buffer) {
+        return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = tsProtoGlobalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (tsProtoGlobalThis.Buffer) {
+        return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return tsProtoGlobalThis.btoa(bin.join(""));
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/composite/proto/gen/google/protobuf/struct.gen.d.ts

@@ -0,0 +1,91 @@
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ *  The JSON representation for `NullValue` is JSON `null`.
+ */
+/**
+ * @public
+ */
+export declare const enum NullValue {
+    /** NULL_VALUE - Null value. */
+    NULL_VALUE = 0
+}
+/**
+ * @public
+ */
+export declare function nullValueFromJSON(object: any): NullValue;
+/**
+ * @public
+ */
+export declare function nullValueToJSON(object: NullValue): string;
+/**
+ * `Struct` represents a structured data value, consisting of fields
+ * which map to dynamically typed values. In some languages, `Struct`
+ * might be supported by a native representation. For example, in
+ * scripting languages like JS a struct is represented as an
+ * object. The details of that representation are described together
+ * with the proto support for the language.
+ *
+ * The JSON representation for `Struct` is JSON object.
+ */
+/**
+ * @public
+ */
+export interface Struct {
+    /** Unordered map of dynamically typed values. */
+    fields: Map<string, any | undefined>;
+}
+/**
+ * @public
+ */
+export interface Struct_FieldsEntry {
+    key: string;
+    value: any | undefined;
+}
+/**
+ * `Value` represents a dynamically typed value which can be either
+ * null, a number, a string, a boolean, a recursive struct value, or a
+ * list of values. A producer of value is expected to set one of these
+ * variants. Absence of any variant indicates an error.
+ *
+ * The JSON representation for `Value` is JSON value.
+ */
+/**
+ * @public
+ */
+export interface Value {
+    kind?: {
+        $case: "nullValue";
+        nullValue: NullValue;
+    } | {
+        $case: "numberValue";
+        numberValue: number;
+    } | {
+        $case: "stringValue";
+        stringValue: string;
+    } | {
+        $case: "boolValue";
+        boolValue: boolean;
+    } | {
+        $case: "structValue";
+        structValue: {
+            [key: string]: any;
+        } | undefined;
+    } | {
+        $case: "listValue";
+        listValue: Array<any> | undefined;
+    };
+}
+/**
+ * `ListValue` is a wrapper around a repeated field of values.
+ *
+ * The JSON representation for `ListValue` is JSON array.
+ */
+/**
+ * @public
+ */
+export interface ListValue {
+    /** Repeated field of dynamically typed values. */
+    values: any[];
+}

package/dist/composite/proto/gen/google/protobuf/struct.gen.js

@@ -0,0 +1,380 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+const protobufPackageSarasa = "google.protobuf";
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ *  The JSON representation for `NullValue` is JSON `null`.
+ */
+/**
+ * @public
+ */
+export var NullValue;
+(function (NullValue) {
+    /** NULL_VALUE - Null value. */
+    NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
+})(NullValue || (NullValue = {}));
+/**
+ * @public
+ */
+export function nullValueFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "NULL_VALUE":
+            return 0 /* NullValue.NULL_VALUE */;
+        default:
+            throw new tsProtoGlobalThis.Error("Unrecognized enum value " + object + " for enum NullValue");
+    }
+}
+/**
+ * @public
+ */
+export function nullValueToJSON(object) {
+    switch (object) {
+        case 0 /* NullValue.NULL_VALUE */:
+            return "NULL_VALUE";
+        default:
+            throw new tsProtoGlobalThis.Error("Unrecognized enum value " + object + " for enum NullValue");
+    }
+}
+function createBaseStruct() {
+    return { fields: new Map() };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const Struct = {
+    encode(message, writer = _m0.Writer.create()) {
+        message.fields.forEach((value, key) => {
+            if (value !== undefined) {
+                Struct_FieldsEntry.encode({ key: key, value }, writer.uint32(10).fork()).ldelim();
+            }
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStruct();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
+                    if (entry1.value !== undefined) {
+                        message.fields.set(entry1.key, entry1.value);
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            fields: isObject(object.fields)
+                ? Object.entries(object.fields).reduce((acc, [key, value]) => {
+                    acc.set(key, value);
+                    return acc;
+                }, new Map())
+                : new Map(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        obj.fields = {};
+        if (message.fields) {
+            message.fields.forEach((v, k) => {
+                obj.fields[k] = v;
+            });
+        }
+        return obj;
+    },
+    wrap(object) {
+        const struct = createBaseStruct();
+        if (object !== undefined) {
+            Object.keys(object).forEach((key) => {
+                struct.fields.set(key, object[key]);
+            });
+        }
+        return struct;
+    },
+    unwrap(message) {
+        const object = {};
+        [...message.fields.keys()].forEach((key) => {
+            object[key] = message.fields.get(key);
+        });
+        return object;
+    },
+};
+function createBaseStruct_FieldsEntry() {
+    return { key: "", value: undefined };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const Struct_FieldsEntry = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStruct_FieldsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object?.value) ? object.value : undefined };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined && (obj.key = message.key);
+        message.value !== undefined && (obj.value = message.value);
+        return obj;
+    },
+};
+function createBaseValue() {
+    return { kind: undefined };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const Value = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.kind?.$case === "nullValue") {
+            writer.uint32(8).int32(message.kind.nullValue);
+        }
+        if (message.kind?.$case === "numberValue") {
+            writer.uint32(17).double(message.kind.numberValue);
+        }
+        if (message.kind?.$case === "stringValue") {
+            writer.uint32(26).string(message.kind.stringValue);
+        }
+        if (message.kind?.$case === "boolValue") {
+            writer.uint32(32).bool(message.kind.boolValue);
+        }
+        if (message.kind?.$case === "structValue") {
+            Struct.encode(Struct.wrap(message.kind.structValue), writer.uint32(42).fork()).ldelim();
+        }
+        if (message.kind?.$case === "listValue") {
+            ListValue.encode(ListValue.wrap(message.kind.listValue), writer.uint32(50).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.kind = { $case: "nullValue", nullValue: reader.int32() };
+                    break;
+                case 2:
+                    message.kind = { $case: "numberValue", numberValue: reader.double() };
+                    break;
+                case 3:
+                    message.kind = { $case: "stringValue", stringValue: reader.string() };
+                    break;
+                case 4:
+                    message.kind = { $case: "boolValue", boolValue: reader.bool() };
+                    break;
+                case 5:
+                    message.kind = { $case: "structValue", structValue: Struct.unwrap(Struct.decode(reader, reader.uint32())) };
+                    break;
+                case 6:
+                    message.kind = { $case: "listValue", listValue: ListValue.unwrap(ListValue.decode(reader, reader.uint32())) };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            kind: isSet(object.nullValue)
+                ? { $case: "nullValue", nullValue: nullValueFromJSON(object.nullValue) }
+                : isSet(object.numberValue)
+                    ? { $case: "numberValue", numberValue: Number(object.numberValue) }
+                    : isSet(object.stringValue)
+                        ? { $case: "stringValue", stringValue: String(object.stringValue) }
+                        : isSet(object.boolValue)
+                            ? { $case: "boolValue", boolValue: Boolean(object.boolValue) }
+                            : isSet(object.structValue)
+                                ? { $case: "structValue", structValue: object.structValue }
+                                : isSet(object.listValue)
+                                    ? { $case: "listValue", listValue: [...object.listValue] }
+                                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.kind?.$case === "nullValue" &&
+            (obj.nullValue = message.kind?.nullValue !== undefined ? nullValueToJSON(message.kind?.nullValue) : undefined);
+        message.kind?.$case === "numberValue" && (obj.numberValue = message.kind?.numberValue);
+        message.kind?.$case === "stringValue" && (obj.stringValue = message.kind?.stringValue);
+        message.kind?.$case === "boolValue" && (obj.boolValue = message.kind?.boolValue);
+        message.kind?.$case === "structValue" && (obj.structValue = message.kind?.structValue);
+        message.kind?.$case === "listValue" && (obj.listValue = message.kind?.listValue);
+        return obj;
+    },
+    wrap(value) {
+        const result = createBaseValue();
+        if (value === null) {
+            result.kind = { $case: "nullValue", nullValue: 0 /* NullValue.NULL_VALUE */ };
+        }
+        else if (typeof value === "boolean") {
+            result.kind = { $case: "boolValue", boolValue: value };
+        }
+        else if (typeof value === "number") {
+            result.kind = { $case: "numberValue", numberValue: value };
+        }
+        else if (typeof value === "string") {
+            result.kind = { $case: "stringValue", stringValue: value };
+        }
+        else if (Array.isArray(value)) {
+            result.kind = { $case: "listValue", listValue: value };
+        }
+        else if (typeof value === "object") {
+            result.kind = { $case: "structValue", structValue: value };
+        }
+        else if (typeof value !== "undefined") {
+            throw new Error("Unsupported any value type: " + typeof value);
+        }
+        return result;
+    },
+    unwrap(message) {
+        if (message.kind?.$case === "nullValue") {
+            return null;
+        }
+        else if (message.kind?.$case === "numberValue") {
+            return message.kind?.numberValue;
+        }
+        else if (message.kind?.$case === "stringValue") {
+            return message.kind?.stringValue;
+        }
+        else if (message.kind?.$case === "boolValue") {
+            return message.kind?.boolValue;
+        }
+        else if (message.kind?.$case === "structValue") {
+            return message.kind?.structValue;
+        }
+        else if (message.kind?.$case === "listValue") {
+            return message.kind?.listValue;
+        }
+        else {
+            return undefined;
+        }
+    },
+};
+function createBaseListValue() {
+    return { values: [] };
+}
+/**
+ * @public
+ */
+/**
+ * @internal
+ */
+export const ListValue = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.values) {
+            Value.encode(Value.wrap(v), writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseListValue();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { values: Array.isArray(object?.values) ? [...object.values] : [] };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.values) {
+            obj.values = message.values.map((e) => e);
+        }
+        else {
+            obj.values = [];
+        }
+        return obj;
+    },
+    wrap(value) {
+        const result = createBaseListValue();
+        result.values = value ?? [];
+        return result;
+    },
+    unwrap(message) {
+        return message.values;
+    },
+};
+var tsProtoGlobalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/composite/serialization.d.ts

@@ -1,6 +1,3 @@
-import { Composite } from './types';
-/**
- * @public
- * @deprecated composite is not being supported so far, please do not use this feature
- */
-export declare function compositeFromJson(jsonComposite: any): Composite;
+import { Composite } from './proto/gen/composite.gen';
+export declare function compositeFromJson(object: any): Composite;
+export declare function compositeFromBinary(buffer: Uint8Array): Composite;

package/dist/composite/serialization.js

@@ -1,36 +1,9 @@
-/**
- * @public
- * @deprecated composite is not being supported so far, please do not use this feature
- */
-export function compositeFromJson(jsonComposite) {
-    if (!jsonComposite)
-        throw new Error('Composite is not well defined');
-    if (!jsonComposite.id || typeof jsonComposite.id !== 'string')
-        throw new Error("Composite doesn't have a valid `id` field");
-    const compositeId = jsonComposite.id;
-    // TODO: Should be there a .version to identify the schema version?
-    if (!Array.isArray(jsonComposite.components))
-        throw new Error(`Composite '${compositeId}' fields 'components' is not an array`);
-    const composite = {
-        id: compositeId,
-        components: []
-    };
-    for (const component of jsonComposite.components) {
-        if (!component.name || typeof component.name !== 'string')
-            throw new Error(`Composite '${compositeId}': The component doesn't have a valid name`);
-        const componentName = component.name;
-        const componentData = new Map();
-        if (typeof component.data !== 'object' || Array.isArray(component.data))
-            throw new Error(`Composite '${compositeId}': Invalid data in component '${component.name}'`);
-        for (const [entityStr, data] of Object.entries(component.data)) {
-            const entity = parseInt(entityStr);
-            componentData.set(entity, data);
-        }
-        composite.components.push({
-            name: componentName,
-            data: componentData,
-            schema: component.schema
-        });
-    }
-    return composite;
+import { Composite } from './proto/gen/composite.gen';
+/* @public @deprecated */
+export function compositeFromJson(object) {
+    return Composite.fromJSON(object);
+}
+/* @public @deprecated */
+export function compositeFromBinary(buffer) {
+    return Composite.decode(buffer);
 }

package/dist/composite/types.d.ts

@@ -1,17 +1,7 @@
-import { Entity } from '../engine/entity';
-import { JsonSchemaExtended } from '../schemas/ISchema';
-/**
- * @public
- * @deprecated composite is not being supported so far, please do not use this feature
- */
-export type Composite = {
-    id: string;
-    components: {
-        name: string;
-        schema?: JsonSchemaExtended;
-        data: Map<Entity, unknown>;
-    }[];
-};
+import type { ComponentData, CompositeComponent, CompositeComponent_DataEntry } from './proto/gen/composite.gen';
+import { Composite } from './proto/gen/composite.gen';
+export type { ComponentData, CompositeComponent, CompositeComponent_DataEntry };
+export { Composite };
 /**
  * @public
  * @deprecated composite is not being supported so far, please do not use this feature

package/dist/composite/types.js

@@ -1 +1,2 @@
-export {};
+import { Composite } from './proto/gen/composite.gen';
+export { Composite };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.1.2",
+  "version": "7.1.3-4448471926.commit-264de76",
   "description": "Decentraland ECS",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -27,7 +27,7 @@
     "ts-proto": "^1.112.0"
   },
   "dependencies": {
-    "@dcl/js-runtime": "7.1.2",
+    "@dcl/js-runtime": "7.1.3-4448471926.commit-264de76",
     "@dcl/protocol": "1.0.0-4408137944.commit-a67c796"
   },
   "files": [
@@ -40,5 +40,5 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "4c363ec1e57406326ff3b3d27941d63b44e7d2e2"
+  "commit": "264de7682c191f5abc8dbe754ea1b7e5fac96c4c"
 }