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

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

@@ -0,0 +1,443 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListValue = exports.Value = exports.Struct_FieldsEntry = exports.Struct = exports.nullValueToJSON = exports.nullValueFromJSON = exports.NullValue = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("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
+ */
+var NullValue;
+(function (NullValue) {
+    /** NULL_VALUE - Null value. */
+    NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
+})(NullValue = exports.NullValue || (exports.NullValue = {}));
+/**
+ * @public
+ */
+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");
+    }
+}
+exports.nullValueFromJSON = nullValueFromJSON;
+/**
+ * @public
+ */
+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");
+    }
+}
+exports.nullValueToJSON = nullValueToJSON;
+function createBaseStruct() {
+    return { fields: new Map() };
+}
+/**
+ * @public
+ */
+var Struct;
+(function (Struct) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        (message.fields).forEach((value, key) => {
+            if (value !== undefined) {
+                Struct_FieldsEntry.encode({ key: key, value }, writer.uint32(10).fork()).ldelim();
+            }
+        });
+        return writer;
+    }
+    Struct.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
+                    if (entry1.value !== undefined) {
+                        message.fields.set(entry1.key, entry1.value);
+                    }
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    Struct.decode = decode;
+    function 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(),
+        };
+    }
+    Struct.fromJSON = fromJSON;
+    function toJSON(message) {
+        const obj = {};
+        obj.fields = {};
+        if (message.fields) {
+            message.fields.forEach((v, k) => {
+                obj.fields[k] = v;
+            });
+        }
+        return obj;
+    }
+    Struct.toJSON = toJSON;
+    function wrap(object) {
+        const struct = createBaseStruct();
+        if (object !== undefined) {
+            Object.keys(object).forEach((key) => {
+                struct.fields.set(key, object[key]);
+            });
+        }
+        return struct;
+    }
+    Struct.wrap = wrap;
+    function unwrap(message) {
+        const object = {};
+        [...message.fields.keys()].forEach((key) => {
+            object[key] = message.fields.get(key);
+        });
+        return object;
+    }
+    Struct.unwrap = unwrap;
+})(Struct = exports.Struct || (exports.Struct = {}));
+function createBaseStruct_FieldsEntry() {
+    return { key: "", value: undefined };
+}
+/**
+ * @public
+ */
+var Struct_FieldsEntry;
+(function (Struct_FieldsEntry) {
+    function encode(message, writer = minimal_1.default.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;
+    }
+    Struct_FieldsEntry.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    Struct_FieldsEntry.decode = decode;
+    function fromJSON(object) {
+        return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object?.value) ? object.value : undefined };
+    }
+    Struct_FieldsEntry.fromJSON = fromJSON;
+    function toJSON(message) {
+        const obj = {};
+        message.key !== undefined && (obj.key = message.key);
+        message.value !== undefined && (obj.value = message.value);
+        return obj;
+    }
+    Struct_FieldsEntry.toJSON = toJSON;
+})(Struct_FieldsEntry = exports.Struct_FieldsEntry || (exports.Struct_FieldsEntry = {}));
+function createBaseValue() {
+    return { kind: undefined };
+}
+/**
+ * @public
+ */
+var Value;
+(function (Value) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        switch (message.kind?.$case) {
+            case "nullValue":
+                writer.uint32(8).int32(message.kind.nullValue);
+                break;
+            case "numberValue":
+                writer.uint32(17).double(message.kind.numberValue);
+                break;
+            case "stringValue":
+                writer.uint32(26).string(message.kind.stringValue);
+                break;
+            case "boolValue":
+                writer.uint32(32).bool(message.kind.boolValue);
+                break;
+            case "structValue":
+                Struct.encode(Struct.wrap(message.kind.structValue), writer.uint32(42).fork()).ldelim();
+                break;
+            case "listValue":
+                ListValue.encode(ListValue.wrap(message.kind.listValue), writer.uint32(50).fork()).ldelim();
+                break;
+        }
+        return writer;
+    }
+    Value.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.kind = { $case: "nullValue", nullValue: reader.int32() };
+                    continue;
+                case 2:
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.kind = { $case: "numberValue", numberValue: reader.double() };
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.kind = { $case: "stringValue", stringValue: reader.string() };
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.kind = { $case: "boolValue", boolValue: reader.bool() };
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.kind = { $case: "structValue", structValue: Struct.unwrap(Struct.decode(reader, reader.uint32())) };
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.kind = { $case: "listValue", listValue: ListValue.unwrap(ListValue.decode(reader, reader.uint32())) };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    Value.decode = decode;
+    function 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,
+        };
+    }
+    Value.fromJSON = fromJSON;
+    function 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;
+    }
+    Value.toJSON = toJSON;
+    function 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;
+    }
+    Value.wrap = wrap;
+    function 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;
+        }
+    }
+    Value.unwrap = unwrap;
+})(Value = exports.Value || (exports.Value = {}));
+function createBaseListValue() {
+    return { values: [] };
+}
+/**
+ * @public
+ */
+var ListValue;
+(function (ListValue) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.values) {
+            Value.encode(Value.wrap(v), writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    }
+    ListValue.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(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:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    ListValue.decode = decode;
+    function fromJSON(object) {
+        return { values: Array.isArray(object?.values) ? [...object.values] : [] };
+    }
+    ListValue.fromJSON = fromJSON;
+    function toJSON(message) {
+        const obj = {};
+        if (message.values) {
+            obj.values = message.values.map((e) => e);
+        }
+        else {
+            obj.values = [];
+        }
+        return obj;
+    }
+    ListValue.toJSON = toJSON;
+    function wrap(array) {
+        const result = createBaseListValue();
+        result.values = array ?? [];
+        return result;
+    }
+    ListValue.wrap = wrap;
+    function unwrap(message) {
+        if (message?.hasOwnProperty("values") && Array.isArray(message.values)) {
+            return message.values;
+        }
+        else {
+            return message;
+        }
+    }
+    ListValue.unwrap = unwrap;
+})(ListValue = exports.ListValue || (exports.ListValue = {}));
+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-cjs/engine/component.d.ts

@@ -0,0 +1,149 @@
+import { ISchema } from '../schemas';
+import { ByteBuffer } from '../serialization/ByteBuffer';
+import { CrdtMessageBody, DeleteComponentMessageBody, PutComponentMessageBody } from '../serialization/crdt';
+import { Entity } from './entity';
+import { DeepReadonly, DeepReadonlySet } from './readonly';
+/**
+ * Component types are used to pick the wire protocol and the conflict resolution algorithm
+ * @public
+ */
+export declare const enum ComponentType {
+    LastWriteWinElementSet = 0,
+    GrowOnlyValueSet = 1
+}
+/**
+ * A conflict resolution message is the response to an outdated or invalid state
+ * in the CRDT.
+ * @public
+ */
+export type ConflictResolutionMessage = PutComponentMessageBody | DeleteComponentMessageBody;
+/**
+ * @public
+ */
+export interface BaseComponent<T> {
+    readonly componentId: number;
+    readonly componentName: string;
+    readonly componentType: ComponentType;
+    readonly schema: ISchema<T>;
+    /**
+     * This function receives a CRDT update and returns a touple with a "conflict
+     * resoluton" message, in case of the sender being updated or null in case of noop/accepted
+     * change. The second element of the touple is the modified/changed/deleted value.
+     * @public
+     */
+    updateFromCrdt(body: CrdtMessageBody): [null | ConflictResolutionMessage, T | undefined];
+    /**
+     * This function returns an iterable with all the CRDT updates that need to be
+     * broadcasted to other actors in the system. After returning, this function
+     * clears the internal dirty state. Updates are produced only once.
+     * @public
+     */
+    getCrdtUpdates(): Iterable<CrdtMessageBody>;
+    /**
+     * This function writes the whole state of the component into a ByteBuffer
+     * @public
+     */
+    dumpCrdtStateToBuffer(buffer: ByteBuffer): void;
+    /**
+     * @public
+     * Marks the entity as deleted and signals it cannot be used ever again. It must
+     * clear the component internal state, produces a synchronization message to remove
+     * the component from the entity.
+     * @param entity - Entity ID that was deleted.
+     */
+    entityDeleted(entity: Entity, markAsDirty: boolean): void;
+    /**
+     * Get if the entity has this component
+     * @param entity - entity to test
+     */
+    has(entity: Entity): boolean;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead),
+     * throws an error if the entity doesn't have the component.
+     * @param entity - Entity that will be used to get the component
+     * @returns
+     */
+    get(entity: Entity): any;
+}
+/**
+ * @public
+ */
+export interface LastWriteWinElementSetComponentDefinition<T> extends BaseComponent<T> {
+    readonly componentType: ComponentType.LastWriteWinElementSet;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead),
+     * throws an error if the entity doesn't have the component.
+     * @param entity - Entity that will be used to get the component
+     * @returns
+     */
+    get(entity: Entity): DeepReadonly<T>;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead), or null if the entity doesn't have the component.
+     * @param entity - Entity that will be used to try to get the component
+     */
+    getOrNull(entity: Entity): DeepReadonly<T> | null;
+    /**
+     * Add the current component to an entity, throw an error if the component already exists (use `createOrReplace` instead).
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity that will be used to create the component
+     * @param val - The initial value
+     */
+    create(entity: Entity, val?: T): T;
+    /**
+     * Add the current component to an entity or replace the content if the entity already has the component
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity that will be used to create or replace the component
+     * @param val - The initial or new value
+     */
+    createOrReplace(entity: Entity, val?: T): T;
+    /**
+     * @public
+     * Delete the current component to an entity, return null if the entity doesn't have the current component.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to delete the component from
+     */
+    deleteFrom(entity: Entity): T | null;
+    /**
+     * Get the mutable component of the entity, throw an error if the entity doesn't have the component.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to get the component from
+     */
+    getMutable(entity: Entity): T;
+    /**
+     * Get the mutable component of the entity, return null if the entity doesn't have the component.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to get the component from
+     */
+    getMutableOrNull(entity: Entity): T | null;
+    /**
+     * Get the mutable component of the entity. If the entity doesn't have the component, it's created.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to get the component from
+     * @param val - The initial value if it doesn't exist
+     */
+    getOrCreateMutable(entity: Entity, initialValue?: T): T;
+}
+/**
+ * @public
+ */
+export interface GrowOnlyValueSetComponentDefinition<T> extends BaseComponent<T> {
+    readonly componentType: ComponentType.GrowOnlyValueSet;
+    /**
+     * Appends an element to the set.
+     * @param entity - Entity that will host the value
+     * @param val - The final value. The Set will freeze the value, it won't be editable from
+     * the script.
+     */
+    addValue(entity: Entity, val: DeepReadonly<T>): DeepReadonlySet<T>;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead),
+     * throws an error if the entity doesn't have the component.
+     * @param entity - Entity that will be used to get the component
+     * @returns
+     */
+    get(entity: Entity): DeepReadonlySet<T>;
+}
+/**
+ * @public
+ */
+export type ComponentDefinition<T> = LastWriteWinElementSetComponentDefinition<T> | GrowOnlyValueSetComponentDefinition<T>;

package/dist-cjs/engine/component.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentType = void 0;
+/**
+ * Component types are used to pick the wire protocol and the conflict resolution algorithm
+ * @public
+ */
+var ComponentType;
+(function (ComponentType) {
+    ComponentType[ComponentType["LastWriteWinElementSet"] = 0] = "LastWriteWinElementSet";
+    ComponentType[ComponentType["GrowOnlyValueSet"] = 1] = "GrowOnlyValueSet";
+})(ComponentType = exports.ComponentType || (exports.ComponentType = {}));

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

@@ -0,0 +1,49 @@
+/**
+ * @public It only defines the type explicitly, no effects.
+ */
+export type uint32 = number;
+/**
+ * @public The Entity is a number type, the cast is only for typescript, the final javascript code treat as a number
+ *  version  number
+ * [31...16][15...0]
+ *
+ * Convertion from entity to its compound numbers:
+ * To get the version => ((entity & MASK_UPPER_16_ON_32) >> 16) & MAX_U16
+ * To get the number  => entity & MAX_U16
+ *
+ * Convertion from its compound numbers to entity:
+ * entity = (entityNumber & MAX_U16) | ((entityVersion & MAX_U16) << 16)
+ */
+export type Entity = number & {
+    __entity_type: '';
+};
+/**
+ * @public
+ */
+export declare enum EntityState {
+    Unknown = 0,
+    /**
+     * The entity was generated and added to the usedEntities set
+     */
+    UsedEntity = 1,
+    /**
+     * The entity was removed from current engine or remotely
+     */
+    Removed = 2,
+    /**
+     * The entity is reserved number.
+     */
+    Reserved = 3
+}
+/**
+ * @intenral
+ */
+export type EntityContainer = {
+    generateEntity(): Entity;
+    removeEntity(entity: Entity): boolean;
+    getEntityState(entity: Entity): EntityState;
+    getExistingEntities(): Set<Entity>;
+    releaseRemovedEntities(): Entity[];
+    updateRemovedEntity(entity: Entity): boolean;
+    updateUsedEntity(entity: Entity): boolean;
+};