@dcl/ecs 7.0.0-3548419522.commit-ddcf4b7 → 7.0.0

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

@@ -0,0 +1,454 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export var YGPositionType;
+(function (YGPositionType) {
+    YGPositionType[YGPositionType["YGPT_RELATIVE"] = 0] = "YGPT_RELATIVE";
+    YGPositionType[YGPositionType["YGPT_ABSOLUTE"] = 1] = "YGPT_ABSOLUTE";
+})(YGPositionType || (YGPositionType = {}));
+export 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 || (YGAlign = {}));
+export 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 || (YGUnit = {}));
+export 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 || (YGFlexDirection = {}));
+export 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 || (YGWrap = {}));
+export 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 || (YGJustify = {}));
+export 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 || (YGOverflow = {}));
+export var YGDisplay;
+(function (YGDisplay) {
+    YGDisplay[YGDisplay["YGD_FLEX"] = 0] = "YGD_FLEX";
+    YGDisplay[YGDisplay["YGD_NONE"] = 1] = "YGD_NONE";
+})(YGDisplay || (YGDisplay = {}));
+export 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 || (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
+    };
+}
+/**
+ * Internal
+ */
+export const PBUiTransform = {
+    encode(message, writer = _m0.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;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBUiTransform();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.parent = reader.int32();
+                    break;
+                case 2:
+                    message.rightOf = reader.int32();
+                    break;
+                case 3:
+                    message.alignContent = reader.int32();
+                    break;
+                case 4:
+                    message.alignItems = reader.int32();
+                    break;
+                case 5:
+                    message.flexWrap = reader.int32();
+                    break;
+                case 6:
+                    message.flexShrink = reader.float();
+                    break;
+                case 7:
+                    message.positionType = reader.int32();
+                    break;
+                case 8:
+                    message.alignSelf = reader.int32();
+                    break;
+                case 9:
+                    message.flexDirection = reader.int32();
+                    break;
+                case 10:
+                    message.justifyContent = reader.int32();
+                    break;
+                case 11:
+                    message.overflow = reader.int32();
+                    break;
+                case 12:
+                    message.display = reader.int32();
+                    break;
+                case 13:
+                    message.flexBasisUnit = reader.int32();
+                    break;
+                case 14:
+                    message.flexBasis = reader.float();
+                    break;
+                case 15:
+                    message.flexGrow = reader.float();
+                    break;
+                case 16:
+                    message.widthUnit = reader.int32();
+                    break;
+                case 17:
+                    message.width = reader.float();
+                    break;
+                case 18:
+                    message.heightUnit = reader.int32();
+                    break;
+                case 19:
+                    message.height = reader.float();
+                    break;
+                case 20:
+                    message.minWidthUnit = reader.int32();
+                    break;
+                case 21:
+                    message.minWidth = reader.float();
+                    break;
+                case 22:
+                    message.minHeightUnit = reader.int32();
+                    break;
+                case 23:
+                    message.minHeight = reader.float();
+                    break;
+                case 24:
+                    message.maxWidthUnit = reader.int32();
+                    break;
+                case 25:
+                    message.maxWidth = reader.float();
+                    break;
+                case 26:
+                    message.maxHeightUnit = reader.int32();
+                    break;
+                case 27:
+                    message.maxHeight = reader.float();
+                    break;
+                case 28:
+                    message.positionLeftUnit = reader.int32();
+                    break;
+                case 29:
+                    message.positionLeft = reader.float();
+                    break;
+                case 30:
+                    message.positionTopUnit = reader.int32();
+                    break;
+                case 31:
+                    message.positionTop = reader.float();
+                    break;
+                case 32:
+                    message.positionRightUnit = reader.int32();
+                    break;
+                case 33:
+                    message.positionRight = reader.float();
+                    break;
+                case 34:
+                    message.positionBottomUnit = reader.int32();
+                    break;
+                case 35:
+                    message.positionBottom = reader.float();
+                    break;
+                case 36:
+                    message.marginLeftUnit = reader.int32();
+                    break;
+                case 37:
+                    message.marginLeft = reader.float();
+                    break;
+                case 38:
+                    message.marginTopUnit = reader.int32();
+                    break;
+                case 39:
+                    message.marginTop = reader.float();
+                    break;
+                case 40:
+                    message.marginRightUnit = reader.int32();
+                    break;
+                case 41:
+                    message.marginRight = reader.float();
+                    break;
+                case 42:
+                    message.marginBottomUnit = reader.int32();
+                    break;
+                case 43:
+                    message.marginBottom = reader.float();
+                    break;
+                case 44:
+                    message.paddingLeftUnit = reader.int32();
+                    break;
+                case 45:
+                    message.paddingLeft = reader.float();
+                    break;
+                case 46:
+                    message.paddingTopUnit = reader.int32();
+                    break;
+                case 47:
+                    message.paddingTop = reader.float();
+                    break;
+                case 48:
+                    message.paddingRightUnit = reader.int32();
+                    break;
+                case 49:
+                    message.paddingRight = reader.float();
+                    break;
+                case 50:
+                    message.paddingBottomUnit = reader.int32();
+                    break;
+                case 51:
+                    message.paddingBottom = reader.float();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/visibility_component.gen.d.ts

@@ -0,0 +1,12 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBVisibilityComponent {
+    /** default=true */
+    visible?: boolean | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBVisibilityComponent: {
+    encode(message: PBVisibilityComponent, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBVisibilityComponent;
+};

package/dist/components/generated/pb/decentraland/sdk/components/visibility_component.gen.js

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBVisibilityComponent() {
+    return { visible: undefined };
+}
+/**
+ * Internal
+ */
+export const PBVisibilityComponent = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.visible !== undefined) {
+            writer.uint32(8).bool(message.visible);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBVisibilityComponent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.visible = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};