@dcl/ecs 7.0.0-3548419522.commit-ddcf4b7 → 7.0.0-3568547351.commit-5420eac

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

@@ -0,0 +1,176 @@
+import { Color3, Color4 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBTextShape() {
+    return {
+        text: '',
+        font: undefined,
+        fontSize: undefined,
+        fontAutoSize: undefined,
+        textAlign: undefined,
+        width: undefined,
+        height: undefined,
+        paddingTop: undefined,
+        paddingRight: undefined,
+        paddingBottom: undefined,
+        paddingLeft: undefined,
+        lineSpacing: undefined,
+        lineCount: undefined,
+        textWrapping: undefined,
+        shadowBlur: undefined,
+        shadowOffsetX: undefined,
+        shadowOffsetY: undefined,
+        outlineWidth: undefined,
+        shadowColor: undefined,
+        outlineColor: undefined,
+        textColor: undefined
+    };
+}
+/**
+ * Internal
+ */
+export const PBTextShape = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.text !== '') {
+            writer.uint32(10).string(message.text);
+        }
+        if (message.font !== undefined) {
+            writer.uint32(16).int32(message.font);
+        }
+        if (message.fontSize !== undefined) {
+            writer.uint32(29).float(message.fontSize);
+        }
+        if (message.fontAutoSize !== undefined) {
+            writer.uint32(32).bool(message.fontAutoSize);
+        }
+        if (message.textAlign !== undefined) {
+            writer.uint32(40).int32(message.textAlign);
+        }
+        if (message.width !== undefined) {
+            writer.uint32(53).float(message.width);
+        }
+        if (message.height !== undefined) {
+            writer.uint32(61).float(message.height);
+        }
+        if (message.paddingTop !== undefined) {
+            writer.uint32(69).float(message.paddingTop);
+        }
+        if (message.paddingRight !== undefined) {
+            writer.uint32(77).float(message.paddingRight);
+        }
+        if (message.paddingBottom !== undefined) {
+            writer.uint32(85).float(message.paddingBottom);
+        }
+        if (message.paddingLeft !== undefined) {
+            writer.uint32(93).float(message.paddingLeft);
+        }
+        if (message.lineSpacing !== undefined) {
+            writer.uint32(101).float(message.lineSpacing);
+        }
+        if (message.lineCount !== undefined) {
+            writer.uint32(104).int32(message.lineCount);
+        }
+        if (message.textWrapping !== undefined) {
+            writer.uint32(112).bool(message.textWrapping);
+        }
+        if (message.shadowBlur !== undefined) {
+            writer.uint32(125).float(message.shadowBlur);
+        }
+        if (message.shadowOffsetX !== undefined) {
+            writer.uint32(133).float(message.shadowOffsetX);
+        }
+        if (message.shadowOffsetY !== undefined) {
+            writer.uint32(141).float(message.shadowOffsetY);
+        }
+        if (message.outlineWidth !== undefined) {
+            writer.uint32(149).float(message.outlineWidth);
+        }
+        if (message.shadowColor !== undefined) {
+            Color3.encode(message.shadowColor, writer.uint32(154).fork()).ldelim();
+        }
+        if (message.outlineColor !== undefined) {
+            Color3.encode(message.outlineColor, writer.uint32(162).fork()).ldelim();
+        }
+        if (message.textColor !== undefined) {
+            Color4.encode(message.textColor, writer.uint32(170).fork()).ldelim();
+        }
+        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 = createBasePBTextShape();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.text = reader.string();
+                    break;
+                case 2:
+                    message.font = reader.int32();
+                    break;
+                case 3:
+                    message.fontSize = reader.float();
+                    break;
+                case 4:
+                    message.fontAutoSize = reader.bool();
+                    break;
+                case 5:
+                    message.textAlign = reader.int32();
+                    break;
+                case 6:
+                    message.width = reader.float();
+                    break;
+                case 7:
+                    message.height = reader.float();
+                    break;
+                case 8:
+                    message.paddingTop = reader.float();
+                    break;
+                case 9:
+                    message.paddingRight = reader.float();
+                    break;
+                case 10:
+                    message.paddingBottom = reader.float();
+                    break;
+                case 11:
+                    message.paddingLeft = reader.float();
+                    break;
+                case 12:
+                    message.lineSpacing = reader.float();
+                    break;
+                case 13:
+                    message.lineCount = reader.int32();
+                    break;
+                case 14:
+                    message.textWrapping = reader.bool();
+                    break;
+                case 15:
+                    message.shadowBlur = reader.float();
+                    break;
+                case 16:
+                    message.shadowOffsetX = reader.float();
+                    break;
+                case 17:
+                    message.shadowOffsetY = reader.float();
+                    break;
+                case 18:
+                    message.outlineWidth = reader.float();
+                    break;
+                case 19:
+                    message.shadowColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 20:
+                    message.outlineColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 21:
+                    message.textColor = Color4.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,13 @@
+import { Color4 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBUiBackground {
+    /** default=(0.0, 0.0, 0.0, 0.0) */
+    backgroundColor?: Color4 | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBUiBackground: {
+    encode(message: PBUiBackground, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBUiBackground;
+};

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import { Color4 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBUiBackground() {
+    return { backgroundColor: undefined };
+}
+/**
+ * Internal
+ */
+export const PBUiBackground = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.backgroundColor !== undefined) {
+            Color4.encode(message.backgroundColor, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBasePBUiBackground();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.backgroundColor = Color4.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,21 @@
+import { Color4 } from '../../common/colors.gen';
+import { TextAlignMode, Font } from './common/texts.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBUiText {
+    value: string;
+    /** default=(1.0,1.0,1.0,1.0) */
+    color?: Color4 | undefined;
+    /** default='center' */
+    textAlign?: TextAlignMode | undefined;
+    /** default=0 */
+    font?: Font | undefined;
+    /** default=10 */
+    fontSize?: number | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBUiText: {
+    encode(message: PBUiText, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBUiText;
+};

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

@@ -0,0 +1,59 @@
+/* eslint-disable */
+import { Color4 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBUiText() {
+    return { value: '', color: undefined, textAlign: undefined, font: undefined, fontSize: undefined };
+}
+/**
+ * Internal
+ */
+export const PBUiText = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.value !== '') {
+            writer.uint32(10).string(message.value);
+        }
+        if (message.color !== undefined) {
+            Color4.encode(message.color, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.textAlign !== undefined) {
+            writer.uint32(24).int32(message.textAlign);
+        }
+        if (message.font !== undefined) {
+            writer.uint32(32).int32(message.font);
+        }
+        if (message.fontSize !== undefined) {
+            writer.uint32(40).int32(message.fontSize);
+        }
+        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 = createBasePBUiText();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.value = reader.string();
+                    break;
+                case 2:
+                    message.color = Color4.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.textAlign = reader.int32();
+                    break;
+                case 4:
+                    message.font = reader.int32();
+                    break;
+                case 5:
+                    message.fontSize = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

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

@@ -0,0 +1,149 @@
+import _m0 from 'protobufjs/minimal';
+export declare const enum YGPositionType {
+    YGPT_RELATIVE = 0,
+    YGPT_ABSOLUTE = 1
+}
+export declare const enum YGAlign {
+    YGA_AUTO = 0,
+    YGA_FLEX_START = 1,
+    YGA_CENTER = 2,
+    YGA_FLEX_END = 3,
+    YGA_STRETCH = 4,
+    YGA_BASELINE = 5,
+    YGA_SPACE_BETWEEN = 6,
+    YGA_SPACE_AROUND = 7
+}
+export declare const enum YGUnit {
+    YGU_UNDEFINED = 0,
+    YGU_POINT = 1,
+    YGU_PERCENT = 2,
+    YGU_AUTO = 3
+}
+export declare const enum YGFlexDirection {
+    YGFD_ROW = 0,
+    YGFD_COLUMN = 1,
+    YGFD_COLUMN_REVERSE = 2,
+    YGFD_ROW_REVERSE = 3
+}
+export declare const enum YGWrap {
+    YGW_NO_WRAP = 0,
+    YGW_WRAP = 1,
+    YGW_WRAP_REVERSE = 2
+}
+export declare const enum YGJustify {
+    YGJ_FLEX_START = 0,
+    YGJ_CENTER = 1,
+    YGJ_FLEX_END = 2,
+    YGJ_SPACE_BETWEEN = 3,
+    YGJ_SPACE_AROUND = 4,
+    YGJ_SPACE_EVENLY = 5
+}
+export declare const enum YGOverflow {
+    YGO_VISIBLE = 0,
+    YGO_HIDDEN = 1,
+    YGO_SCROLL = 2
+}
+export declare const enum YGDisplay {
+    YGD_FLEX = 0,
+    YGD_NONE = 1
+}
+export declare const enum YGEdge {
+    YGE_LEFT = 0,
+    YGE_TOP = 1,
+    YGE_RIGHT = 2,
+    YGE_BOTTOM = 3,
+    YGE_START = 4,
+    YGE_END = 5,
+    YGE_HORIZONTAL = 6,
+    YGE_VERTICAL = 7,
+    YGE_ALL = 8
+}
+export interface PBUiTransform {
+    parent: number;
+    rightOf: number;
+    /** default: YGAlign.YGA_FLEX_START */
+    alignContent?: YGAlign | undefined;
+    /** default: YGAlign.YGA_STRETCH */
+    alignItems?: YGAlign | undefined;
+    /** default: YGWrap.YGW_WRAP */
+    flexWrap?: YGWrap | undefined;
+    /** default: 1 */
+    flexShrink?: number | undefined;
+    /** YGPositionType.YGPT_RELATIVE */
+    positionType: YGPositionType;
+    /** YGAlign.YGA_AUTO */
+    alignSelf: YGAlign;
+    /** YGFlexDirection.YGFD_ROW */
+    flexDirection: YGFlexDirection;
+    /** YGJustify.YGJ_FLEX_START */
+    justifyContent: YGJustify;
+    /** YGOverflow.YGO_VISIBLE */
+    overflow: YGOverflow;
+    /** YGDisplay.YGD_FLEX */
+    display: YGDisplay;
+    /** YGUnit.YGU_UNDEFINED */
+    flexBasisUnit: YGUnit;
+    flexBasis: number;
+    flexGrow: number;
+    /** YGUnit.YGU_UNDEFINED */
+    widthUnit: YGUnit;
+    width: number;
+    /** YGUnit.YGU_UNDEFINED */
+    heightUnit: YGUnit;
+    height: number;
+    /** YGUnit.YGU_UNDEFINED */
+    minWidthUnit: YGUnit;
+    minWidth: number;
+    /** YGUnit.YGU_UNDEFINED */
+    minHeightUnit: YGUnit;
+    minHeight: number;
+    /** YGUnit.YGU_UNDEFINED */
+    maxWidthUnit: YGUnit;
+    maxWidth: number;
+    /** YGUnit.YGU_UNDEFINED */
+    maxHeightUnit: YGUnit;
+    maxHeight: number;
+    /** YGUnit.YGU_UNDEFINED */
+    positionLeftUnit: YGUnit;
+    positionLeft: number;
+    /** YGUnit.YGU_UNDEFINED */
+    positionTopUnit: YGUnit;
+    positionTop: number;
+    /** YGUnit.YGU_UNDEFINED */
+    positionRightUnit: YGUnit;
+    positionRight: number;
+    /** YGUnit.YGU_UNDEFINED */
+    positionBottomUnit: YGUnit;
+    positionBottom: number;
+    /** YGUnit.YGU_UNDEFINED */
+    marginLeftUnit: YGUnit;
+    marginLeft: number;
+    /** YGUnit.YGU_UNDEFINED */
+    marginTopUnit: YGUnit;
+    marginTop: number;
+    /** YGUnit.YGU_UNDEFINED */
+    marginRightUnit: YGUnit;
+    marginRight: number;
+    /** YGUnit.YGU_UNDEFINED */
+    marginBottomUnit: YGUnit;
+    marginBottom: number;
+    /** YGUnit.YGU_UNDEFINED */
+    paddingLeftUnit: YGUnit;
+    paddingLeft: number;
+    /** YGUnit.YGU_UNDEFINED */
+    paddingTopUnit: YGUnit;
+    paddingTop: number;
+    /** YGUnit.YGU_UNDEFINED */
+    paddingRightUnit: YGUnit;
+    paddingRight: number;
+    /** YGUnit.YGU_UNDEFINED */
+    paddingBottomUnit: YGUnit;
+    paddingBottom: number;
+}
+/**
+ * Internal
+ */
+export declare const PBUiTransform: {
+    encode(message: PBUiTransform, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBUiTransform;
+};