@dcl/ecs 7.24.1-27294863236.commit-bff98c4 → 7.24.1-27387182535.commit-de44c20

package/dist/components/generated/pb/google/protobuf/descriptor.gen.js

@@ -7,23 +7,45 @@ const protobufPackageSarasa = "google.protobuf";
  */
 export var FieldDescriptorProto_Type;
 (function (FieldDescriptorProto_Type) {
+    /**
+     * TYPE_DOUBLE - 0 is reserved for errors.
+     * Order is weird for historical reasons.
+     */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_DOUBLE"] = 1] = "TYPE_DOUBLE";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FLOAT"] = 2] = "TYPE_FLOAT";
+    /**
+     * TYPE_INT64 - Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+     * negative values are likely.
+     */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_INT64"] = 3] = "TYPE_INT64";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_UINT64"] = 4] = "TYPE_UINT64";
+    /**
+     * TYPE_INT32 - Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+     * negative values are likely.
+     */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_INT32"] = 5] = "TYPE_INT32";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FIXED64"] = 6] = "TYPE_FIXED64";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FIXED32"] = 7] = "TYPE_FIXED32";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_BOOL"] = 8] = "TYPE_BOOL";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_STRING"] = 9] = "TYPE_STRING";
+    /**
+     * TYPE_GROUP - Tag-delimited aggregate.
+     * Group type is deprecated and not supported in proto3. However, Proto3
+     * implementations should still be able to parse the group wire format and
+     * treat group fields as unknown fields.
+     */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_GROUP"] = 10] = "TYPE_GROUP";
+    /** TYPE_MESSAGE - Length-delimited aggregate. */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_MESSAGE"] = 11] = "TYPE_MESSAGE";
+    /** TYPE_BYTES - New in version 2. */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_BYTES"] = 12] = "TYPE_BYTES";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_UINT32"] = 13] = "TYPE_UINT32";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_ENUM"] = 14] = "TYPE_ENUM";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SFIXED32"] = 15] = "TYPE_SFIXED32";
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SFIXED64"] = 16] = "TYPE_SFIXED64";
+    /** TYPE_SINT32 - Uses ZigZag encoding. */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SINT32"] = 17] = "TYPE_SINT32";
+    /** TYPE_SINT64 - Uses ZigZag encoding. */
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SINT64"] = 18] = "TYPE_SINT64";
 })(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {}));
 /**
@@ -31,17 +53,22 @@ export var FieldDescriptorProto_Type;
  */
 export var FieldDescriptorProto_Label;
 (function (FieldDescriptorProto_Label) {
+    /** LABEL_OPTIONAL - 0 is reserved for errors */
     FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_OPTIONAL"] = 1] = "LABEL_OPTIONAL";
     FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_REQUIRED"] = 2] = "LABEL_REQUIRED";
     FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_REPEATED"] = 3] = "LABEL_REPEATED";
 })(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {}));
+/** Generated classes can be optimized for speed or code size. */
 /**
  * @public
  */
 export var FileOptions_OptimizeMode;
 (function (FileOptions_OptimizeMode) {
+    /** SPEED - Generate complete code for parsing, serialization, */
     FileOptions_OptimizeMode[FileOptions_OptimizeMode["SPEED"] = 1] = "SPEED";
+    /** CODE_SIZE - etc. */
     FileOptions_OptimizeMode[FileOptions_OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE";
+    /** LITE_RUNTIME - Generate code using MessageLite and the lite runtime. */
     FileOptions_OptimizeMode[FileOptions_OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME";
 })(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {}));
 /**
@@ -49,6 +76,7 @@ export var FileOptions_OptimizeMode;
  */
 export var FieldOptions_CType;
 (function (FieldOptions_CType) {
+    /** STRING - Default mode. */
     FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING";
     FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD";
     FieldOptions_CType[FieldOptions_CType["STRING_PIECE"] = 2] = "STRING_PIECE";
@@ -58,10 +86,29 @@ export var FieldOptions_CType;
  */
 export var FieldOptions_JSType;
 (function (FieldOptions_JSType) {
+    /** JS_NORMAL - Use the default type. */
     FieldOptions_JSType[FieldOptions_JSType["JS_NORMAL"] = 0] = "JS_NORMAL";
+    /** JS_STRING - Use JavaScript strings. */
     FieldOptions_JSType[FieldOptions_JSType["JS_STRING"] = 1] = "JS_STRING";
+    /** JS_NUMBER - Use JavaScript numbers. */
     FieldOptions_JSType[FieldOptions_JSType["JS_NUMBER"] = 2] = "JS_NUMBER";
 })(FieldOptions_JSType || (FieldOptions_JSType = {}));
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+ * or neither? HTTP based RPC implementation may choose GET verb for safe
+ * methods, and PUT verb for idempotent methods instead of the default POST.
+ */
+/**
+ * @public
+ */
+export var MethodOptions_IdempotencyLevel;
+(function (MethodOptions_IdempotencyLevel) {
+    MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN";
+    /** NO_SIDE_EFFECTS - implies idempotent */
+    MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS";
+    /** IDEMPOTENT - idempotent, but may have side effects */
+    MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENT"] = 2] = "IDEMPOTENT";
+})(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {}));
 function createBaseFileDescriptorSet() {
     return { file: [] };
 }
@@ -399,7 +446,7 @@ export var DescriptorProto;
     DescriptorProto.decode = decode;
 })(DescriptorProto || (DescriptorProto = {}));
 function createBaseDescriptorProto_ExtensionRange() {
-    return { start: 0, end: 0 };
+    return { start: 0, end: 0, options: undefined };
 }
 /**
  * @public
@@ -413,6 +460,9 @@ export var DescriptorProto_ExtensionRange;
         if (message.end !== 0) {
             writer.uint32(16).int32(message.end);
         }
+        if (message.options !== undefined) {
+            ExtensionRangeOptions.encode(message.options, writer.uint32(26).fork()).ldelim();
+        }
         return writer;
     }
     DescriptorProto_ExtensionRange.encode = encode;
@@ -435,6 +485,12 @@ export var DescriptorProto_ExtensionRange;
                     }
                     message.end = reader.int32();
                     continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.options = ExtensionRangeOptions.decode(reader, reader.uint32());
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -492,6 +548,44 @@ export var DescriptorProto_ReservedRange;
     }
     DescriptorProto_ReservedRange.decode = decode;
 })(DescriptorProto_ReservedRange || (DescriptorProto_ReservedRange = {}));
+function createBaseExtensionRangeOptions() {
+    return { uninterpretedOption: [] };
+}
+/**
+ * @public
+ */
+export var ExtensionRangeOptions;
+(function (ExtensionRangeOptions) {
+    function encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.uninterpretedOption) {
+            UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
+        }
+        return writer;
+    }
+    ExtensionRangeOptions.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExtensionRangeOptions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 999:
+                    if (tag !== 7994) {
+                        break;
+                    }
+                    message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    ExtensionRangeOptions.decode = decode;
+})(ExtensionRangeOptions || (ExtensionRangeOptions = {}));
 function createBaseFieldDescriptorProto() {
     return {
         name: "",
@@ -504,6 +598,7 @@ function createBaseFieldDescriptorProto() {
         oneofIndex: 0,
         jsonName: "",
         options: undefined,
+        proto3Optional: false,
     };
 }
 /**
@@ -542,6 +637,9 @@ export var FieldDescriptorProto;
         if (message.options !== undefined) {
             FieldOptions.encode(message.options, writer.uint32(66).fork()).ldelim();
         }
+        if (message.proto3Optional === true) {
+            writer.uint32(136).bool(message.proto3Optional);
+        }
         return writer;
     }
     FieldDescriptorProto.encode = encode;
@@ -612,6 +710,12 @@ export var FieldDescriptorProto;
                     }
                     message.options = FieldOptions.decode(reader, reader.uint32());
                     continue;
+                case 17:
+                    if (tag !== 136) {
+                        break;
+                    }
+                    message.proto3Optional = reader.bool();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -670,7 +774,7 @@ export var OneofDescriptorProto;
     OneofDescriptorProto.decode = decode;
 })(OneofDescriptorProto || (OneofDescriptorProto = {}));
 function createBaseEnumDescriptorProto() {
-    return { name: "", value: [], options: undefined };
+    return { name: "", value: [], options: undefined, reservedRange: [], reservedName: [] };
 }
 /**
  * @public
@@ -687,6 +791,12 @@ export var EnumDescriptorProto;
         if (message.options !== undefined) {
             EnumOptions.encode(message.options, writer.uint32(26).fork()).ldelim();
         }
+        for (const v of message.reservedRange) {
+            EnumDescriptorProto_EnumReservedRange.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.reservedName) {
+            writer.uint32(42).string(v);
+        }
         return writer;
     }
     EnumDescriptorProto.encode = encode;
@@ -715,6 +825,18 @@ export var EnumDescriptorProto;
                     }
                     message.options = EnumOptions.decode(reader, reader.uint32());
                     continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.reservedRange.push(EnumDescriptorProto_EnumReservedRange.decode(reader, reader.uint32()));
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.reservedName.push(reader.string());
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -725,6 +847,53 @@ export var EnumDescriptorProto;
     }
     EnumDescriptorProto.decode = decode;
 })(EnumDescriptorProto || (EnumDescriptorProto = {}));
+function createBaseEnumDescriptorProto_EnumReservedRange() {
+    return { start: 0, end: 0 };
+}
+/**
+ * @public
+ */
+export var EnumDescriptorProto_EnumReservedRange;
+(function (EnumDescriptorProto_EnumReservedRange) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.start !== 0) {
+            writer.uint32(8).int32(message.start);
+        }
+        if (message.end !== 0) {
+            writer.uint32(16).int32(message.end);
+        }
+        return writer;
+    }
+    EnumDescriptorProto_EnumReservedRange.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEnumDescriptorProto_EnumReservedRange();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.start = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.end = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    EnumDescriptorProto_EnumReservedRange.decode = decode;
+})(EnumDescriptorProto_EnumReservedRange || (EnumDescriptorProto_EnumReservedRange = {}));
 function createBaseEnumValueDescriptorProto() {
     return { name: "", number: 0, options: undefined };
 }
@@ -939,10 +1108,16 @@ function createBaseFileOptions() {
         ccGenericServices: false,
         javaGenericServices: false,
         pyGenericServices: false,
+        phpGenericServices: false,
         deprecated: false,
         ccEnableArenas: false,
         objcClassPrefix: "",
         csharpNamespace: "",
+        swiftPrefix: "",
+        phpClassPrefix: "",
+        phpNamespace: "",
+        phpMetadataNamespace: "",
+        rubyPackage: "",
         uninterpretedOption: [],
     };
 }
@@ -982,6 +1157,9 @@ export var FileOptions;
         if (message.pyGenericServices === true) {
             writer.uint32(144).bool(message.pyGenericServices);
         }
+        if (message.phpGenericServices === true) {
+            writer.uint32(336).bool(message.phpGenericServices);
+        }
         if (message.deprecated === true) {
             writer.uint32(184).bool(message.deprecated);
         }
@@ -994,6 +1172,21 @@ export var FileOptions;
         if (message.csharpNamespace !== "") {
             writer.uint32(298).string(message.csharpNamespace);
         }
+        if (message.swiftPrefix !== "") {
+            writer.uint32(314).string(message.swiftPrefix);
+        }
+        if (message.phpClassPrefix !== "") {
+            writer.uint32(322).string(message.phpClassPrefix);
+        }
+        if (message.phpNamespace !== "") {
+            writer.uint32(330).string(message.phpNamespace);
+        }
+        if (message.phpMetadataNamespace !== "") {
+            writer.uint32(354).string(message.phpMetadataNamespace);
+        }
+        if (message.rubyPackage !== "") {
+            writer.uint32(362).string(message.rubyPackage);
+        }
         for (const v of message.uninterpretedOption) {
             UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
         }
@@ -1067,6 +1260,12 @@ export var FileOptions;
                     }
                     message.pyGenericServices = reader.bool();
                     continue;
+                case 42:
+                    if (tag !== 336) {
+                        break;
+                    }
+                    message.phpGenericServices = reader.bool();
+                    continue;
                 case 23:
                     if (tag !== 184) {
                         break;
@@ -1091,6 +1290,36 @@ export var FileOptions;
                     }
                     message.csharpNamespace = reader.string();
                     continue;
+                case 39:
+                    if (tag !== 314) {
+                        break;
+                    }
+                    message.swiftPrefix = reader.string();
+                    continue;
+                case 40:
+                    if (tag !== 322) {
+                        break;
+                    }
+                    message.phpClassPrefix = reader.string();
+                    continue;
+                case 41:
+                    if (tag !== 330) {
+                        break;
+                    }
+                    message.phpNamespace = reader.string();
+                    continue;
+                case 44:
+                    if (tag !== 354) {
+                        break;
+                    }
+                    message.phpMetadataNamespace = reader.string();
+                    continue;
+                case 45:
+                    if (tag !== 362) {
+                        break;
+                    }
+                    message.rubyPackage = reader.string();
+                    continue;
                 case 999:
                     if (tag !== 7994) {
                         break;
@@ -1188,7 +1417,16 @@ export var MessageOptions;
     MessageOptions.decode = decode;
 })(MessageOptions || (MessageOptions = {}));
 function createBaseFieldOptions() {
-    return { ctype: 0, packed: false, jstype: 0, lazy: false, deprecated: false, weak: false, uninterpretedOption: [] };
+    return {
+        ctype: 0,
+        packed: false,
+        jstype: 0,
+        lazy: false,
+        unverifiedLazy: false,
+        deprecated: false,
+        weak: false,
+        uninterpretedOption: [],
+    };
 }
 /**
  * @public
@@ -1208,6 +1446,9 @@ export var FieldOptions;
         if (message.lazy === true) {
             writer.uint32(40).bool(message.lazy);
         }
+        if (message.unverifiedLazy === true) {
+            writer.uint32(120).bool(message.unverifiedLazy);
+        }
         if (message.deprecated === true) {
             writer.uint32(24).bool(message.deprecated);
         }
@@ -1251,6 +1492,12 @@ export var FieldOptions;
                     }
                     message.lazy = reader.bool();
                     continue;
+                case 15:
+                    if (tag !== 120) {
+                        break;
+                    }
+                    message.unverifiedLazy = reader.bool();
+                    continue;
                 case 3:
                     if (tag !== 24) {
                         break;
@@ -1468,7 +1715,7 @@ export var ServiceOptions;
     ServiceOptions.decode = decode;
 })(ServiceOptions || (ServiceOptions = {}));
 function createBaseMethodOptions() {
-    return { deprecated: false, uninterpretedOption: [] };
+    return { deprecated: false, idempotencyLevel: 0, uninterpretedOption: [] };
 }
 /**
  * @public
@@ -1479,6 +1726,9 @@ export var MethodOptions;
         if (message.deprecated === true) {
             writer.uint32(264).bool(message.deprecated);
         }
+        if (message.idempotencyLevel !== 0) {
+            writer.uint32(272).int32(message.idempotencyLevel);
+        }
         for (const v of message.uninterpretedOption) {
             UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
         }
@@ -1498,6 +1748,12 @@ export var MethodOptions;
                     }
                     message.deprecated = reader.bool();
                     continue;
+                case 34:
+                    if (tag !== 272) {
+                        break;
+                    }
+                    message.idempotencyLevel = reader.int32();
+                    continue;
                 case 999:
                     if (tag !== 7994) {
                         break;

package/dist-cjs/components/extended/AudioSource.d.ts

@@ -8,11 +8,13 @@ export interface AudioSourceComponentDefinitionExtended extends LastWriteWinElem
     /**
      * @public
      *
-     * Set playing=true the sound `$name`
-     * @param entity - entity with AudioSource component
+     * Play the sound `src` on the given entity. Creates the AudioSource component
+     * if it does not yet exist. Always emits a CRDT PUT, so repeated calls with
+     * identical parameters reliably retrigger playback.
+     * @param entity - target entity (AudioSource will be created if missing)
      * @param src - the path to the sound to play
      * @param resetCursor - the sound starts at 0 or continues from the current cursor position
-     * @returns true in successful playing, false if it doesn't find the AudioSource component
+     * @returns always true; retained for backwards compatibility
      */
     playSound(entity: Entity, src: string, resetCursor?: boolean): boolean;
     /**

package/dist-cjs/components/extended/AudioSource.js

@@ -7,13 +7,13 @@ function defineAudioSourceComponent(engine) {
     return {
         ...theComponent,
         playSound(entity, src, resetCursor = true) {
-            // Get the mutable to modify
-            const audioSource = theComponent.getMutableOrNull(entity);
-            if (!audioSource)
-                return false;
-            audioSource.audioClipUrl = src;
-            audioSource.playing = true;
-            audioSource.currentTime = resetCursor ? 0 : audioSource.currentTime;
+            const existing = theComponent.getOrNull(entity);
+            theComponent.createOrReplace(entity, {
+                ...existing,
+                audioClipUrl: src,
+                playing: true,
+                currentTime: resetCursor ? 0 : existing?.currentTime ?? 0
+            });
             return true;
         },
         stopSound(entity, resetCursor = true) {