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

package/dist-cjs/composite/path.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveComposite = exports.dirname = exports.resolve = void 0;
+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 */
+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 '.';
+    }
+}
+exports.resolve = resolve;
+/* istanbul ignore next */
+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);
+}
+exports.dirname = dirname;
+function resolveComposite(path, cwd) {
+    const absolutePath = path.startsWith('.') ? resolve(cwd, path) : resolve(path);
+    return absolutePath.substring(1);
+}
+exports.resolveComposite = resolveComposite;

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

@@ -0,0 +1,71 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * @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 CompositeDefinition {
+    version: number;
+    components: CompositeComponent[];
+}
+/**
+ * @public
+ */
+export declare namespace ComponentData {
+    function encode(message: ComponentData, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): ComponentData;
+    function fromJSON(object: any): ComponentData;
+    function toJSON(message: ComponentData): unknown;
+}
+/**
+ * @public
+ */
+export declare namespace CompositeComponent {
+    function encode(message: CompositeComponent, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): CompositeComponent;
+    function fromJSON(object: any): CompositeComponent;
+    function toJSON(message: CompositeComponent): unknown;
+}
+/**
+ * @public
+ */
+export declare namespace CompositeComponent_DataEntry {
+    function encode(message: CompositeComponent_DataEntry, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): CompositeComponent_DataEntry;
+    function fromJSON(object: any): CompositeComponent_DataEntry;
+    function toJSON(message: CompositeComponent_DataEntry): unknown;
+}
+/**
+ * @public
+ */
+export declare namespace CompositeDefinition {
+    function encode(message: CompositeDefinition, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): CompositeDefinition;
+    function fromJSON(object: any): CompositeDefinition;
+    function toJSON(message: CompositeDefinition): unknown;
+}

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

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeDefinition = exports.CompositeComponent_DataEntry = exports.CompositeComponent = exports.ComponentData = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const struct_gen_1 = require("./google/protobuf/struct.gen");
+const protobufPackageSarasa = "";
+function createBaseComponentData() {
+    return { data: undefined };
+}
+/**
+ * @public
+ */
+var ComponentData;
+(function (ComponentData) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        switch (message.data?.$case) {
+            case "json":
+                struct_gen_1.Value.encode(struct_gen_1.Value.wrap(message.data.json), writer.uint32(10).fork()).ldelim();
+                break;
+            case "binary":
+                writer.uint32(18).bytes(message.data.binary);
+                break;
+        }
+        return writer;
+    }
+    ComponentData.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 = createBaseComponentData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.data = { $case: "json", json: struct_gen_1.Value.unwrap(struct_gen_1.Value.decode(reader, reader.uint32())) };
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.data = { $case: "binary", binary: reader.bytes() };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    ComponentData.decode = decode;
+    function fromJSON(object) {
+        return {
+            data: isSet(object.json)
+                ? { $case: "json", json: object.json }
+                : isSet(object.binary)
+                    ? { $case: "binary", binary: bytesFromBase64(object.binary) }
+                    : undefined,
+        };
+    }
+    ComponentData.fromJSON = fromJSON;
+    function 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;
+    }
+    ComponentData.toJSON = toJSON;
+})(ComponentData = exports.ComponentData || (exports.ComponentData = {}));
+function createBaseCompositeComponent() {
+    return { name: "", jsonSchema: undefined, data: new Map() };
+}
+/**
+ * @public
+ */
+var CompositeComponent;
+(function (CompositeComponent) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.jsonSchema !== undefined) {
+            struct_gen_1.Value.encode(struct_gen_1.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;
+    }
+    CompositeComponent.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 = createBaseCompositeComponent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.jsonSchema = struct_gen_1.Value.unwrap(struct_gen_1.Value.decode(reader, reader.uint32()));
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    const entry3 = CompositeComponent_DataEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.data.set(entry3.key, entry3.value);
+                    }
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    CompositeComponent.decode = decode;
+    function 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(),
+        };
+    }
+    CompositeComponent.fromJSON = fromJSON;
+    function 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;
+    }
+    CompositeComponent.toJSON = toJSON;
+})(CompositeComponent = exports.CompositeComponent || (exports.CompositeComponent = {}));
+function createBaseCompositeComponent_DataEntry() {
+    return { key: 0, value: undefined };
+}
+/**
+ * @public
+ */
+var CompositeComponent_DataEntry;
+(function (CompositeComponent_DataEntry) {
+    function encode(message, writer = minimal_1.default.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;
+    }
+    CompositeComponent_DataEntry.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 = createBaseCompositeComponent_DataEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.key = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = ComponentData.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    CompositeComponent_DataEntry.decode = decode;
+    function fromJSON(object) {
+        return {
+            key: isSet(object.key) ? Number(object.key) : 0,
+            value: isSet(object.value) ? ComponentData.fromJSON(object.value) : undefined,
+        };
+    }
+    CompositeComponent_DataEntry.fromJSON = fromJSON;
+    function 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;
+    }
+    CompositeComponent_DataEntry.toJSON = toJSON;
+})(CompositeComponent_DataEntry = exports.CompositeComponent_DataEntry || (exports.CompositeComponent_DataEntry = {}));
+function createBaseCompositeDefinition() {
+    return { version: 0, components: [] };
+}
+/**
+ * @public
+ */
+var CompositeDefinition;
+(function (CompositeDefinition) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.version !== 0) {
+            writer.uint32(8).int32(message.version);
+        }
+        for (const v of message.components) {
+            CompositeComponent.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    }
+    CompositeDefinition.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 = createBaseCompositeDefinition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.version = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.components.push(CompositeComponent.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    CompositeDefinition.decode = decode;
+    function fromJSON(object) {
+        return {
+            version: isSet(object.version) ? Number(object.version) : 0,
+            components: Array.isArray(object?.components)
+                ? object.components.map((e) => CompositeComponent.fromJSON(e))
+                : [],
+        };
+    }
+    CompositeDefinition.fromJSON = fromJSON;
+    function toJSON(message) {
+        const obj = {};
+        message.version !== undefined && (obj.version = Math.round(message.version));
+        if (message.components) {
+            obj.components = message.components.map((e) => e ? CompositeComponent.toJSON(e) : undefined);
+        }
+        else {
+            obj.components = [];
+        }
+        return obj;
+    }
+    CompositeDefinition.toJSON = toJSON;
+})(CompositeDefinition = exports.CompositeDefinition || (exports.CompositeDefinition = {}));
+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-cjs/composite/proto/gen/google/protobuf/struct.gen.d.ts

@@ -0,0 +1,138 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * `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[];
+}
+/**
+ * @public
+ */
+export declare namespace Struct {
+    function encode(message: Struct, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): Struct;
+    function fromJSON(object: any): Struct;
+    function toJSON(message: Struct): unknown;
+    function wrap(object: {
+        [key: string]: any;
+    } | undefined): Struct;
+    function unwrap(message: Struct): {
+        [key: string]: any;
+    };
+}
+/**
+ * @public
+ */
+export declare namespace Struct_FieldsEntry {
+    function encode(message: Struct_FieldsEntry, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): Struct_FieldsEntry;
+    function fromJSON(object: any): Struct_FieldsEntry;
+    function toJSON(message: Struct_FieldsEntry): unknown;
+}
+/**
+ * @public
+ */
+export declare namespace Value {
+    function encode(message: Value, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): Value;
+    function fromJSON(object: any): Value;
+    function toJSON(message: Value): unknown;
+    function wrap(value: any): Value;
+    function unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace ListValue {
+    function encode(message: ListValue, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): ListValue;
+    function fromJSON(object: any): ListValue;
+    function toJSON(message: ListValue): unknown;
+    function wrap(array: Array<any> | undefined): ListValue;
+    function unwrap(message: ListValue): Array<any>;
+}