@dcl/ecs 7.1.12-4982571416.commit-0b87aa7 → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/components/generated/pb/decentraland/sdk/components/ui_transform.gen.js

@@ -0,0 +1,644 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBUiTransform = exports.YGEdge = exports.YGDisplay = exports.YGOverflow = exports.YGJustify = exports.YGWrap = exports.YGFlexDirection = exports.YGUnit = exports.YGAlign = exports.YGPositionType = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const protobufPackageSarasa = "decentraland.sdk.components";
+/**
+ * @public
+ */
+var YGPositionType;
+(function (YGPositionType) {
+    YGPositionType[YGPositionType["YGPT_RELATIVE"] = 0] = "YGPT_RELATIVE";
+    YGPositionType[YGPositionType["YGPT_ABSOLUTE"] = 1] = "YGPT_ABSOLUTE";
+})(YGPositionType = exports.YGPositionType || (exports.YGPositionType = {}));
+/**
+ * @public
+ */
+var YGAlign;
+(function (YGAlign) {
+    YGAlign[YGAlign["YGA_AUTO"] = 0] = "YGA_AUTO";
+    YGAlign[YGAlign["YGA_FLEX_START"] = 1] = "YGA_FLEX_START";
+    YGAlign[YGAlign["YGA_CENTER"] = 2] = "YGA_CENTER";
+    YGAlign[YGAlign["YGA_FLEX_END"] = 3] = "YGA_FLEX_END";
+    YGAlign[YGAlign["YGA_STRETCH"] = 4] = "YGA_STRETCH";
+    YGAlign[YGAlign["YGA_BASELINE"] = 5] = "YGA_BASELINE";
+    YGAlign[YGAlign["YGA_SPACE_BETWEEN"] = 6] = "YGA_SPACE_BETWEEN";
+    YGAlign[YGAlign["YGA_SPACE_AROUND"] = 7] = "YGA_SPACE_AROUND";
+})(YGAlign = exports.YGAlign || (exports.YGAlign = {}));
+/**
+ * @public
+ */
+var YGUnit;
+(function (YGUnit) {
+    YGUnit[YGUnit["YGU_UNDEFINED"] = 0] = "YGU_UNDEFINED";
+    YGUnit[YGUnit["YGU_POINT"] = 1] = "YGU_POINT";
+    YGUnit[YGUnit["YGU_PERCENT"] = 2] = "YGU_PERCENT";
+    YGUnit[YGUnit["YGU_AUTO"] = 3] = "YGU_AUTO";
+})(YGUnit = exports.YGUnit || (exports.YGUnit = {}));
+/**
+ * @public
+ */
+var YGFlexDirection;
+(function (YGFlexDirection) {
+    YGFlexDirection[YGFlexDirection["YGFD_ROW"] = 0] = "YGFD_ROW";
+    YGFlexDirection[YGFlexDirection["YGFD_COLUMN"] = 1] = "YGFD_COLUMN";
+    YGFlexDirection[YGFlexDirection["YGFD_COLUMN_REVERSE"] = 2] = "YGFD_COLUMN_REVERSE";
+    YGFlexDirection[YGFlexDirection["YGFD_ROW_REVERSE"] = 3] = "YGFD_ROW_REVERSE";
+})(YGFlexDirection = exports.YGFlexDirection || (exports.YGFlexDirection = {}));
+/**
+ * @public
+ */
+var YGWrap;
+(function (YGWrap) {
+    YGWrap[YGWrap["YGW_NO_WRAP"] = 0] = "YGW_NO_WRAP";
+    YGWrap[YGWrap["YGW_WRAP"] = 1] = "YGW_WRAP";
+    YGWrap[YGWrap["YGW_WRAP_REVERSE"] = 2] = "YGW_WRAP_REVERSE";
+})(YGWrap = exports.YGWrap || (exports.YGWrap = {}));
+/**
+ * @public
+ */
+var YGJustify;
+(function (YGJustify) {
+    YGJustify[YGJustify["YGJ_FLEX_START"] = 0] = "YGJ_FLEX_START";
+    YGJustify[YGJustify["YGJ_CENTER"] = 1] = "YGJ_CENTER";
+    YGJustify[YGJustify["YGJ_FLEX_END"] = 2] = "YGJ_FLEX_END";
+    YGJustify[YGJustify["YGJ_SPACE_BETWEEN"] = 3] = "YGJ_SPACE_BETWEEN";
+    YGJustify[YGJustify["YGJ_SPACE_AROUND"] = 4] = "YGJ_SPACE_AROUND";
+    YGJustify[YGJustify["YGJ_SPACE_EVENLY"] = 5] = "YGJ_SPACE_EVENLY";
+})(YGJustify = exports.YGJustify || (exports.YGJustify = {}));
+/**
+ * @public
+ */
+var YGOverflow;
+(function (YGOverflow) {
+    YGOverflow[YGOverflow["YGO_VISIBLE"] = 0] = "YGO_VISIBLE";
+    YGOverflow[YGOverflow["YGO_HIDDEN"] = 1] = "YGO_HIDDEN";
+    YGOverflow[YGOverflow["YGO_SCROLL"] = 2] = "YGO_SCROLL";
+})(YGOverflow = exports.YGOverflow || (exports.YGOverflow = {}));
+/**
+ * @public
+ */
+var YGDisplay;
+(function (YGDisplay) {
+    YGDisplay[YGDisplay["YGD_FLEX"] = 0] = "YGD_FLEX";
+    YGDisplay[YGDisplay["YGD_NONE"] = 1] = "YGD_NONE";
+})(YGDisplay = exports.YGDisplay || (exports.YGDisplay = {}));
+/**
+ * @public
+ */
+var YGEdge;
+(function (YGEdge) {
+    YGEdge[YGEdge["YGE_LEFT"] = 0] = "YGE_LEFT";
+    YGEdge[YGEdge["YGE_TOP"] = 1] = "YGE_TOP";
+    YGEdge[YGEdge["YGE_RIGHT"] = 2] = "YGE_RIGHT";
+    YGEdge[YGEdge["YGE_BOTTOM"] = 3] = "YGE_BOTTOM";
+    YGEdge[YGEdge["YGE_START"] = 4] = "YGE_START";
+    YGEdge[YGEdge["YGE_END"] = 5] = "YGE_END";
+    YGEdge[YGEdge["YGE_HORIZONTAL"] = 6] = "YGE_HORIZONTAL";
+    YGEdge[YGEdge["YGE_VERTICAL"] = 7] = "YGE_VERTICAL";
+    YGEdge[YGEdge["YGE_ALL"] = 8] = "YGE_ALL";
+})(YGEdge = exports.YGEdge || (exports.YGEdge = {}));
+function createBasePBUiTransform() {
+    return {
+        parent: 0,
+        rightOf: 0,
+        alignContent: undefined,
+        alignItems: undefined,
+        flexWrap: undefined,
+        flexShrink: undefined,
+        positionType: 0,
+        alignSelf: 0,
+        flexDirection: 0,
+        justifyContent: 0,
+        overflow: 0,
+        display: 0,
+        flexBasisUnit: 0,
+        flexBasis: 0,
+        flexGrow: 0,
+        widthUnit: 0,
+        width: 0,
+        heightUnit: 0,
+        height: 0,
+        minWidthUnit: 0,
+        minWidth: 0,
+        minHeightUnit: 0,
+        minHeight: 0,
+        maxWidthUnit: 0,
+        maxWidth: 0,
+        maxHeightUnit: 0,
+        maxHeight: 0,
+        positionLeftUnit: 0,
+        positionLeft: 0,
+        positionTopUnit: 0,
+        positionTop: 0,
+        positionRightUnit: 0,
+        positionRight: 0,
+        positionBottomUnit: 0,
+        positionBottom: 0,
+        marginLeftUnit: 0,
+        marginLeft: 0,
+        marginTopUnit: 0,
+        marginTop: 0,
+        marginRightUnit: 0,
+        marginRight: 0,
+        marginBottomUnit: 0,
+        marginBottom: 0,
+        paddingLeftUnit: 0,
+        paddingLeft: 0,
+        paddingTopUnit: 0,
+        paddingTop: 0,
+        paddingRightUnit: 0,
+        paddingRight: 0,
+        paddingBottomUnit: 0,
+        paddingBottom: 0,
+    };
+}
+/**
+ * @public
+ */
+var PBUiTransform;
+(function (PBUiTransform) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.parent !== 0) {
+            writer.uint32(8).int32(message.parent);
+        }
+        if (message.rightOf !== 0) {
+            writer.uint32(16).int32(message.rightOf);
+        }
+        if (message.alignContent !== undefined) {
+            writer.uint32(24).int32(message.alignContent);
+        }
+        if (message.alignItems !== undefined) {
+            writer.uint32(32).int32(message.alignItems);
+        }
+        if (message.flexWrap !== undefined) {
+            writer.uint32(40).int32(message.flexWrap);
+        }
+        if (message.flexShrink !== undefined) {
+            writer.uint32(53).float(message.flexShrink);
+        }
+        if (message.positionType !== 0) {
+            writer.uint32(56).int32(message.positionType);
+        }
+        if (message.alignSelf !== 0) {
+            writer.uint32(64).int32(message.alignSelf);
+        }
+        if (message.flexDirection !== 0) {
+            writer.uint32(72).int32(message.flexDirection);
+        }
+        if (message.justifyContent !== 0) {
+            writer.uint32(80).int32(message.justifyContent);
+        }
+        if (message.overflow !== 0) {
+            writer.uint32(88).int32(message.overflow);
+        }
+        if (message.display !== 0) {
+            writer.uint32(96).int32(message.display);
+        }
+        if (message.flexBasisUnit !== 0) {
+            writer.uint32(104).int32(message.flexBasisUnit);
+        }
+        if (message.flexBasis !== 0) {
+            writer.uint32(117).float(message.flexBasis);
+        }
+        if (message.flexGrow !== 0) {
+            writer.uint32(125).float(message.flexGrow);
+        }
+        if (message.widthUnit !== 0) {
+            writer.uint32(128).int32(message.widthUnit);
+        }
+        if (message.width !== 0) {
+            writer.uint32(141).float(message.width);
+        }
+        if (message.heightUnit !== 0) {
+            writer.uint32(144).int32(message.heightUnit);
+        }
+        if (message.height !== 0) {
+            writer.uint32(157).float(message.height);
+        }
+        if (message.minWidthUnit !== 0) {
+            writer.uint32(160).int32(message.minWidthUnit);
+        }
+        if (message.minWidth !== 0) {
+            writer.uint32(173).float(message.minWidth);
+        }
+        if (message.minHeightUnit !== 0) {
+            writer.uint32(176).int32(message.minHeightUnit);
+        }
+        if (message.minHeight !== 0) {
+            writer.uint32(189).float(message.minHeight);
+        }
+        if (message.maxWidthUnit !== 0) {
+            writer.uint32(192).int32(message.maxWidthUnit);
+        }
+        if (message.maxWidth !== 0) {
+            writer.uint32(205).float(message.maxWidth);
+        }
+        if (message.maxHeightUnit !== 0) {
+            writer.uint32(208).int32(message.maxHeightUnit);
+        }
+        if (message.maxHeight !== 0) {
+            writer.uint32(221).float(message.maxHeight);
+        }
+        if (message.positionLeftUnit !== 0) {
+            writer.uint32(224).int32(message.positionLeftUnit);
+        }
+        if (message.positionLeft !== 0) {
+            writer.uint32(237).float(message.positionLeft);
+        }
+        if (message.positionTopUnit !== 0) {
+            writer.uint32(240).int32(message.positionTopUnit);
+        }
+        if (message.positionTop !== 0) {
+            writer.uint32(253).float(message.positionTop);
+        }
+        if (message.positionRightUnit !== 0) {
+            writer.uint32(256).int32(message.positionRightUnit);
+        }
+        if (message.positionRight !== 0) {
+            writer.uint32(269).float(message.positionRight);
+        }
+        if (message.positionBottomUnit !== 0) {
+            writer.uint32(272).int32(message.positionBottomUnit);
+        }
+        if (message.positionBottom !== 0) {
+            writer.uint32(285).float(message.positionBottom);
+        }
+        if (message.marginLeftUnit !== 0) {
+            writer.uint32(288).int32(message.marginLeftUnit);
+        }
+        if (message.marginLeft !== 0) {
+            writer.uint32(301).float(message.marginLeft);
+        }
+        if (message.marginTopUnit !== 0) {
+            writer.uint32(304).int32(message.marginTopUnit);
+        }
+        if (message.marginTop !== 0) {
+            writer.uint32(317).float(message.marginTop);
+        }
+        if (message.marginRightUnit !== 0) {
+            writer.uint32(320).int32(message.marginRightUnit);
+        }
+        if (message.marginRight !== 0) {
+            writer.uint32(333).float(message.marginRight);
+        }
+        if (message.marginBottomUnit !== 0) {
+            writer.uint32(336).int32(message.marginBottomUnit);
+        }
+        if (message.marginBottom !== 0) {
+            writer.uint32(349).float(message.marginBottom);
+        }
+        if (message.paddingLeftUnit !== 0) {
+            writer.uint32(352).int32(message.paddingLeftUnit);
+        }
+        if (message.paddingLeft !== 0) {
+            writer.uint32(365).float(message.paddingLeft);
+        }
+        if (message.paddingTopUnit !== 0) {
+            writer.uint32(368).int32(message.paddingTopUnit);
+        }
+        if (message.paddingTop !== 0) {
+            writer.uint32(381).float(message.paddingTop);
+        }
+        if (message.paddingRightUnit !== 0) {
+            writer.uint32(384).int32(message.paddingRightUnit);
+        }
+        if (message.paddingRight !== 0) {
+            writer.uint32(397).float(message.paddingRight);
+        }
+        if (message.paddingBottomUnit !== 0) {
+            writer.uint32(400).int32(message.paddingBottomUnit);
+        }
+        if (message.paddingBottom !== 0) {
+            writer.uint32(413).float(message.paddingBottom);
+        }
+        return writer;
+    }
+    PBUiTransform.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 = createBasePBUiTransform();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.parent = reader.int32();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.rightOf = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.alignContent = reader.int32();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.alignItems = reader.int32();
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.flexWrap = reader.int32();
+                    continue;
+                case 6:
+                    if (tag !== 53) {
+                        break;
+                    }
+                    message.flexShrink = reader.float();
+                    continue;
+                case 7:
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.positionType = reader.int32();
+                    continue;
+                case 8:
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.alignSelf = reader.int32();
+                    continue;
+                case 9:
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.flexDirection = reader.int32();
+                    continue;
+                case 10:
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.justifyContent = reader.int32();
+                    continue;
+                case 11:
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.overflow = reader.int32();
+                    continue;
+                case 12:
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.display = reader.int32();
+                    continue;
+                case 13:
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.flexBasisUnit = reader.int32();
+                    continue;
+                case 14:
+                    if (tag !== 117) {
+                        break;
+                    }
+                    message.flexBasis = reader.float();
+                    continue;
+                case 15:
+                    if (tag !== 125) {
+                        break;
+                    }
+                    message.flexGrow = reader.float();
+                    continue;
+                case 16:
+                    if (tag !== 128) {
+                        break;
+                    }
+                    message.widthUnit = reader.int32();
+                    continue;
+                case 17:
+                    if (tag !== 141) {
+                        break;
+                    }
+                    message.width = reader.float();
+                    continue;
+                case 18:
+                    if (tag !== 144) {
+                        break;
+                    }
+                    message.heightUnit = reader.int32();
+                    continue;
+                case 19:
+                    if (tag !== 157) {
+                        break;
+                    }
+                    message.height = reader.float();
+                    continue;
+                case 20:
+                    if (tag !== 160) {
+                        break;
+                    }
+                    message.minWidthUnit = reader.int32();
+                    continue;
+                case 21:
+                    if (tag !== 173) {
+                        break;
+                    }
+                    message.minWidth = reader.float();
+                    continue;
+                case 22:
+                    if (tag !== 176) {
+                        break;
+                    }
+                    message.minHeightUnit = reader.int32();
+                    continue;
+                case 23:
+                    if (tag !== 189) {
+                        break;
+                    }
+                    message.minHeight = reader.float();
+                    continue;
+                case 24:
+                    if (tag !== 192) {
+                        break;
+                    }
+                    message.maxWidthUnit = reader.int32();
+                    continue;
+                case 25:
+                    if (tag !== 205) {
+                        break;
+                    }
+                    message.maxWidth = reader.float();
+                    continue;
+                case 26:
+                    if (tag !== 208) {
+                        break;
+                    }
+                    message.maxHeightUnit = reader.int32();
+                    continue;
+                case 27:
+                    if (tag !== 221) {
+                        break;
+                    }
+                    message.maxHeight = reader.float();
+                    continue;
+                case 28:
+                    if (tag !== 224) {
+                        break;
+                    }
+                    message.positionLeftUnit = reader.int32();
+                    continue;
+                case 29:
+                    if (tag !== 237) {
+                        break;
+                    }
+                    message.positionLeft = reader.float();
+                    continue;
+                case 30:
+                    if (tag !== 240) {
+                        break;
+                    }
+                    message.positionTopUnit = reader.int32();
+                    continue;
+                case 31:
+                    if (tag !== 253) {
+                        break;
+                    }
+                    message.positionTop = reader.float();
+                    continue;
+                case 32:
+                    if (tag !== 256) {
+                        break;
+                    }
+                    message.positionRightUnit = reader.int32();
+                    continue;
+                case 33:
+                    if (tag !== 269) {
+                        break;
+                    }
+                    message.positionRight = reader.float();
+                    continue;
+                case 34:
+                    if (tag !== 272) {
+                        break;
+                    }
+                    message.positionBottomUnit = reader.int32();
+                    continue;
+                case 35:
+                    if (tag !== 285) {
+                        break;
+                    }
+                    message.positionBottom = reader.float();
+                    continue;
+                case 36:
+                    if (tag !== 288) {
+                        break;
+                    }
+                    message.marginLeftUnit = reader.int32();
+                    continue;
+                case 37:
+                    if (tag !== 301) {
+                        break;
+                    }
+                    message.marginLeft = reader.float();
+                    continue;
+                case 38:
+                    if (tag !== 304) {
+                        break;
+                    }
+                    message.marginTopUnit = reader.int32();
+                    continue;
+                case 39:
+                    if (tag !== 317) {
+                        break;
+                    }
+                    message.marginTop = reader.float();
+                    continue;
+                case 40:
+                    if (tag !== 320) {
+                        break;
+                    }
+                    message.marginRightUnit = reader.int32();
+                    continue;
+                case 41:
+                    if (tag !== 333) {
+                        break;
+                    }
+                    message.marginRight = reader.float();
+                    continue;
+                case 42:
+                    if (tag !== 336) {
+                        break;
+                    }
+                    message.marginBottomUnit = reader.int32();
+                    continue;
+                case 43:
+                    if (tag !== 349) {
+                        break;
+                    }
+                    message.marginBottom = reader.float();
+                    continue;
+                case 44:
+                    if (tag !== 352) {
+                        break;
+                    }
+                    message.paddingLeftUnit = reader.int32();
+                    continue;
+                case 45:
+                    if (tag !== 365) {
+                        break;
+                    }
+                    message.paddingLeft = reader.float();
+                    continue;
+                case 46:
+                    if (tag !== 368) {
+                        break;
+                    }
+                    message.paddingTopUnit = reader.int32();
+                    continue;
+                case 47:
+                    if (tag !== 381) {
+                        break;
+                    }
+                    message.paddingTop = reader.float();
+                    continue;
+                case 48:
+                    if (tag !== 384) {
+                        break;
+                    }
+                    message.paddingRightUnit = reader.int32();
+                    continue;
+                case 49:
+                    if (tag !== 397) {
+                        break;
+                    }
+                    message.paddingRight = reader.float();
+                    continue;
+                case 50:
+                    if (tag !== 400) {
+                        break;
+                    }
+                    message.paddingBottomUnit = reader.int32();
+                    continue;
+                case 51:
+                    if (tag !== 413) {
+                        break;
+                    }
+                    message.paddingBottom = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBUiTransform.decode = decode;
+})(PBUiTransform = exports.PBUiTransform || (exports.PBUiTransform = {}));

package/dist-cjs/components/generated/pb/decentraland/sdk/components/video_event.gen.d.ts

@@ -0,0 +1,33 @@
+import _m0 from "protobufjs/minimal";
+/**
+ * @public
+ */
+export declare const enum VideoState {
+    VS_NONE = 0,
+    VS_ERROR = 1,
+    VS_LOADING = 2,
+    VS_READY = 3,
+    VS_PLAYING = 4,
+    VS_BUFFERING = 5,
+    VS_SEEKING = 6,
+    VS_PAUSED = 7
+}
+/**
+ * @public
+ */
+export interface PBVideoEvent {
+    /** monotonic counter */
+    timestamp: number;
+    /** number of tick in which the event was produced, equals to EngineInfo.tick_number */
+    tickNumber: number;
+    currentOffset: number;
+    videoLength: number;
+    state: VideoState;
+}
+/**
+ * @public
+ */
+export declare namespace PBVideoEvent {
+    function encode(message: PBVideoEvent, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBVideoEvent;
+}