@draftbit/core 42.1.5 → 42.1.7-71d4c6.1

package/src/components/Carousel.js

@@ -0,0 +1,85 @@
+import * as React from "react";
+import { withTheme } from "../theming";
+import { ScrollView, View, StyleSheet, Dimensions, } from "react-native";
+import Image from "./Image";
+import { COMPONENT_TYPES, createResizeModeProp, createColorProp, } from "@draftbit/types";
+const screenWidth = Dimensions.get("window").width;
+function Pager({ color, index, length, }) {
+    return (React.createElement(View, { style: styles.pager }, Array.from({ length }).map((_, i) => {
+        const current = index === i;
+        const opacity = current ? 1 : 0.5;
+        const size = current ? 10 : 8;
+        return (React.createElement(View, { key: i, style: [
+                styles.bullet,
+                { backgroundColor: color, opacity, width: size, height: size },
+            ] }));
+    })));
+}
+function Carousel({ data, children, dotColor = "strong", style, ...rest }) {
+    const [index, setIndex] = React.useState(0);
+    const length = React.Children.count(children);
+    const itemsLength = (data?.length ?? 0) + length;
+    const slides = Array.isArray(data) ? data : [];
+    const { width, height } = StyleSheet.flatten(style || {});
+    const slideWidth = width || screenWidth;
+    const slideHeight = height || 250;
+    return (React.createElement(View, { style: [styles.container, style], ...rest },
+        React.createElement(ScrollView, { pagingEnabled: true, horizontal: true, decelerationRate: "fast", scrollEventThrottle: 200, showsHorizontalScrollIndicator: false, onScroll: ({ nativeEvent }) => {
+                const layoutWidth = nativeEvent.layoutMeasurement.width;
+                const offset = nativeEvent.contentOffset.x;
+                const currentIndex = Math.ceil(offset / layoutWidth);
+                setIndex(currentIndex);
+            } },
+            slides.length > 0
+                ? slides.map((item, i) => {
+                    return (React.createElement(Image, { key: i, resizeMode: "cover", source: typeof item === "string" ? { uri: item } : item, style: [{ width: slideWidth, height: slideHeight }] }));
+                })
+                : null,
+            React.Children.map(children, (child) => {
+                const s = child?.props?.style || {};
+                return (React.createElement(View, { style: { width: slideWidth } }, React.cloneElement(child, {
+                    style: { ...s, width: slideWidth },
+                })));
+            })),
+        React.createElement(Pager, { color: dotColor, index: index, length: itemsLength })));
+}
+const styles = StyleSheet.create({
+    container: {
+        height: 250,
+        position: "relative",
+        width: screenWidth,
+        backgroundColor: "#eee",
+    },
+    pager: {
+        position: "absolute",
+        bottom: 12,
+        left: 0,
+        right: 0,
+        flexDirection: "row",
+        justifyContent: "center",
+        alignItems: "center",
+    },
+    bullet: {
+        marginHorizontal: 2,
+        width: 10,
+        height: 10,
+        borderRadius: 20,
+        backgroundColor: "#000",
+    },
+});
+export default withTheme(Carousel);
+export const SEED_DATA = [
+    {
+        name: "Carousel",
+        tag: "Carousel",
+        category: COMPONENT_TYPES.media,
+        description: "A horizontal scrolling carousel of images",
+        layout: {},
+        props: {
+            resizeMode: createResizeModeProp(),
+            dotColor: createColorProp({
+                label: "Dot color",
+            }),
+        },
+    },
+];

package/src/components/Checkbox/Checkbox.js

@@ -0,0 +1,114 @@
+import * as React from "react";
+import { View, StyleSheet, } from "react-native";
+import { COMPONENT_TYPES, createBoolProp, createIconProp, createStaticNumberProp, createColorProp, createFieldNameProp, GROUPS, Triggers, } from "@draftbit/types";
+import { useTheme } from "../../theming";
+import Touchable from "../Touchable";
+import { usePrevious } from "../../hooks";
+export var CheckboxStatus;
+(function (CheckboxStatus) {
+    CheckboxStatus["Checked"] = "checked";
+    CheckboxStatus["Unchecked"] = "unchecked";
+    CheckboxStatus["Indeterminate"] = "indeterminate";
+})(CheckboxStatus || (CheckboxStatus = {}));
+const Checkbox = ({ Icon, status = CheckboxStatus.Unchecked, disabled = false, onPress = () => { }, color, uncheckedColor, indeterminateColor, initialValue, checkedIcon = "MaterialCommunityIcons/checkbox-marked", uncheckedIcon = "MaterialCommunityIcons/checkbox-blank-outline", indeterminateIcon = "AntDesign/minussquareo", size = 24, style, ...rest }) => {
+    const previousInitialValue = usePrevious(initialValue);
+    React.useEffect(() => {
+        if (initialValue !== previousInitialValue) {
+            onPress(initialValue);
+        }
+    }, [initialValue, previousInitialValue, onPress]);
+    const { colors } = useTheme();
+    const colorsMap = {
+        [CheckboxStatus.Checked]: color || colors.primary,
+        [CheckboxStatus.Unchecked]: uncheckedColor || colors.primary,
+        [CheckboxStatus.Indeterminate]: indeterminateColor || colors.light,
+    };
+    const iconsMap = {
+        [CheckboxStatus.Checked]: checkedIcon,
+        [CheckboxStatus.Unchecked]: uncheckedIcon,
+        [CheckboxStatus.Indeterminate]: indeterminateIcon,
+    };
+    const checkboxColor = colorsMap[status];
+    return (React.createElement(Touchable, { ...rest, onPress: () => onPress(status === "unchecked" ? true : false), disabled: disabled, accessibilityState: { disabled }, accessibilityRole: "button", accessibilityLiveRegion: "polite", style: [styles.container, style, { width: size, height: size }] },
+        React.createElement(Icon, { style: styles.icon, name: iconsMap[status], size: size, color: checkboxColor }),
+        React.createElement(View, { style: [StyleSheet.absoluteFill, styles.fillContainer] },
+            React.createElement(View, { style: [
+                    styles.fill,
+                    { opacity: disabled ? 0.5 : 1 },
+                    { borderColor: checkboxColor },
+                ] }))));
+};
+const styles = StyleSheet.create({
+    container: {
+        borderRadius: 18,
+    },
+    fillContainer: {
+        alignItems: "center",
+        justifyContent: "center",
+    },
+    icon: {
+        alignSelf: "center",
+    },
+    fill: {
+        borderRadius: 5,
+        width: 30,
+        height: 30,
+        alignSelf: "center",
+    },
+});
+export default Checkbox;
+export const SEED_DATA = {
+    name: "Checkbox",
+    tag: "Checkbox",
+    category: COMPONENT_TYPES.input,
+    triggers: [Triggers.OnPress],
+    props: {
+        fieldName: createFieldNameProp({
+            defaultValue: "checkboxValue",
+            valuePropName: "status",
+            handlerPropName: "onPress",
+        }),
+        color: createColorProp({
+            group: GROUPS.basic,
+            label: "Color",
+            description: "Color for the button (used when the checkbox is checked)",
+            defaultValue: null,
+        }),
+        uncheckedColor: createColorProp({
+            group: GROUPS.basic,
+            label: "Unselected Color",
+            description: "Color for the button when the checkbox is unchecked",
+            defaultValue: null,
+        }),
+        indeterminateColor: createColorProp({
+            group: GROUPS.basic,
+            label: "Indeterminate Color",
+            description: "Color for the button when the checkbox is indeterminate",
+            defaultValue: null,
+        }),
+        disabled: createBoolProp({
+            label: "Disabled",
+            description: "Whether the checkbox is disabled",
+        }),
+        size: createStaticNumberProp({
+            label: "Size",
+            description: "Specifies the size of the icon",
+            defaultValue: null,
+        }),
+        checkedIcon: createIconProp({
+            label: "Checked Icon",
+            description: 'Icon to show when the checkbox status is "checked"',
+            defaultValue: null,
+        }),
+        uncheckedIcon: createIconProp({
+            label: "Unchecked Icon",
+            description: 'Icon to show when the checkbox status is "unchecked"',
+            defaultValue: null,
+        }),
+        indeterminateIcon: createIconProp({
+            label: "Indeterminate Icon",
+            description: 'Icon to show when the checkbox status is "indeterminate"',
+            defaultValue: null,
+        }),
+    },
+};

package/src/components/Checkbox/CheckboxGroup.js

@@ -0,0 +1,46 @@
+import * as React from "react";
+import { View } from "react-native";
+import { GROUPS, COMPONENT_TYPES, FORM_TYPES, createTextProp, PROP_TYPES, createFieldNameProp, createDirectionProp, Triggers, } from "@draftbit/types";
+import { checkboxGroupContext, Direction } from "./context";
+const { Provider } = checkboxGroupContext;
+const CheckboxGroup = ({ direction = Direction.Vertical, values, onValueChange = () => { }, style, children, ...rest }) => {
+    const _containerStyle = [
+        {
+            flexDirection: direction === Direction.Horizontal ? "row" : "column",
+            overflow: "hidden",
+        },
+    ];
+    if (direction !== Direction.Vertical) {
+        _containerStyle.push({
+            alignItems: "center",
+        });
+    }
+    return (React.createElement(View, { style: [{ minHeight: 40 }, style], ...rest },
+        React.createElement(Provider, { value: { values, onValueChange, direction } },
+            React.createElement(View, { style: _containerStyle }, children))));
+};
+export default CheckboxGroup;
+export const SEED_DATA = {
+    name: "Checkbox Group",
+    tag: "CheckboxGroup",
+    category: COMPONENT_TYPES.deprecated,
+    layout: {},
+    triggers: [Triggers.OnValueChange],
+    props: {
+        direction: createDirectionProp(),
+        values: createTextProp({
+            group: GROUPS.data,
+            formType: FORM_TYPES.flatArray,
+            propType: PROP_TYPES.ARRAY,
+            label: "Values",
+            description: "Currently selected values of the checkbox group",
+            required: true,
+            defaultValue: null,
+        }),
+        fieldName: createFieldNameProp({
+            defaultValue: "checkboxGroupValue",
+            handlerPropName: "onValueChange",
+            valuePropName: "checkboxGroupValue",
+        }),
+    },
+};

package/src/components/Checkbox/CheckboxRow.js

@@ -0,0 +1,109 @@
+import * as React from "react";
+import { StyleSheet, View, Platform, } from "react-native";
+import Checkbox, { CheckboxStatus } from "./Checkbox";
+import Text from "../Text";
+import { useCheckboxGroupContext } from "./context";
+import { createTextProp, createTextStyle, createRowDirectionProp, createFieldNameProp, COMPONENT_TYPES, Triggers, } from "@draftbit/types";
+import { Direction as GroupDirection } from "./context";
+import Touchable from "../Touchable";
+import { extractStyles } from "../../utilities";
+export var Direction;
+(function (Direction) {
+    Direction["Row"] = "row";
+    Direction["RowReverse"] = "row-reverse";
+})(Direction || (Direction = {}));
+const getCheckboxAlignment = (parentDirection, direction) => {
+    if (parentDirection === GroupDirection.Horizontal) {
+        return direction === Direction.Row ? "flex-start" : "flex-end";
+    }
+    else if (direction === Direction.RowReverse) {
+        return "flex-start";
+    }
+    else {
+        return "flex-end";
+    }
+};
+const renderLabel = (value, labelStyle, textStyle) => {
+    if (typeof value === "string") {
+        return React.createElement(Text, { style: [labelStyle, textStyle] }, value);
+    }
+    else {
+        return React.createElement(React.Fragment, null, value);
+    }
+};
+const CheckboxRow = ({ Icon, label = "Label", value, onPress = () => { }, labelContainerStyle, labelStyle, checkboxStyle, direction = Direction.Row, status, disabled, style, ...rest }) => {
+    const { values: selectedValues, onValueChange, direction: parentDirection, } = useCheckboxGroupContext();
+    const values = Array.isArray(selectedValues) ? selectedValues : [];
+    const isChecked = status === CheckboxStatus.Checked || values.includes(value);
+    const handlePress = () => {
+        if (!disabled) {
+            onPress(value);
+            onValueChange && onValueChange(value, !isChecked);
+        }
+    };
+    const { textStyles, viewStyles } = extractStyles(style);
+    return (React.createElement(Touchable, { onPress: handlePress, style: [styles.mainParent, { flexDirection: direction }, viewStyles], disabled: disabled, ...rest },
+        React.createElement(View, { style: [
+                styles.label,
+                {
+                    alignItems: direction === Direction.Row ? "flex-start" : "flex-end",
+                },
+                labelContainerStyle,
+            ] }, renderLabel(label, labelStyle, textStyles)),
+        React.createElement(View, { style: {
+                flex: 1,
+                alignItems: getCheckboxAlignment(parentDirection, direction),
+            } },
+            React.createElement(Checkbox, { Icon: Icon, status: status || values.includes(value)
+                    ? CheckboxStatus.Checked
+                    : CheckboxStatus.Unchecked, onPress: handlePress, style: checkboxStyle, disabled: disabled }))));
+};
+const styles = StyleSheet.create({
+    mainParent: {
+        alignItems: "center",
+        justifyContent: "space-around",
+        paddingStart: 20,
+        minHeight: 50,
+        paddingEnd: 20,
+        flex: 1,
+        ...Platform.select({
+            web: {
+                cursor: "pointer",
+                userSelect: "none",
+            },
+        }),
+    },
+    label: {
+        flex: 3,
+    },
+});
+export default CheckboxRow;
+export const SEED_DATA = {
+    name: "Checkbox Row",
+    tag: "CheckboxRow",
+    category: COMPONENT_TYPES.deprecated,
+    layout: {
+        minHeight: 50,
+    },
+    triggers: [Triggers.OnPress],
+    props: {
+        label: createTextProp({
+            label: "Label",
+            description: "Label to show with the checkbox",
+            required: true,
+            defaultValue: "First Option",
+        }),
+        labelStyle: createTextStyle({
+            label: "Label Style",
+            description: "Change the styles of the label",
+            required: false,
+            editable: false,
+        }),
+        direction: createRowDirectionProp(),
+        fieldName: createFieldNameProp({
+            defaultValue: "unchecked",
+            valuePropName: "status",
+            handlerPropName: "onPress",
+        }),
+    },
+};

package/src/components/Checkbox/context.js

@@ -0,0 +1,14 @@
+import { createContext, useContext } from "react";
+export var Direction;
+(function (Direction) {
+    Direction["Horizontal"] = "horizontal";
+    Direction["Vertical"] = "vertical";
+})(Direction || (Direction = {}));
+export const checkboxGroupContext = createContext({
+    onValueChange: () => { },
+    values: [],
+    direction: undefined,
+});
+export function useCheckboxGroupContext() {
+    return useContext(checkboxGroupContext);
+}

package/src/components/Checkbox/index.js

@@ -0,0 +1,3 @@
+export { default as Checkbox } from "./Checkbox";
+export { default as CheckboxGroup } from "./CheckboxGroup";
+export { default as CheckboxRow } from "./CheckboxRow";

package/src/components/CircleImage.js

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { Image, } from "react-native";
+import Config from "./Config";
+import { GROUPS, COMPONENT_TYPES, FORM_TYPES, PROP_TYPES, createImageProp, } from "@draftbit/types";
+const CircleImage = ({ source = Config.placeholderImageURL, size = 60, style, ...props }) => {
+    const borderRadius = size / 2;
+    return (React.createElement(Image, { style: [{ width: size, height: size, borderRadius }, style], source: typeof source === "string" ? { uri: source } : source, resizeMode: "cover", ...props }));
+};
+export default CircleImage;
+export const SEED_DATA = {
+    name: "Circle Image",
+    tag: "CircleImage",
+    description: "A circle image",
+    category: COMPONENT_TYPES.media,
+    props: {
+        source: createImageProp(),
+        size: {
+            group: GROUPS.basic,
+            label: "Size",
+            description: "Size of your circle image",
+            editable: true,
+            required: false,
+            formType: FORM_TYPES.number,
+            propType: PROP_TYPES.NUMBER,
+            min: 0,
+            max: 300,
+            precision: 0,
+            step: 1,
+            defaultValue: 60,
+        },
+    },
+};

package/src/components/CircularProgress.js

@@ -0,0 +1,78 @@
+import React from "react";
+import { View } from "react-native";
+import { Svg, Path, G } from "react-native-svg";
+class CircularProgress extends React.Component {
+    polarToCartesian = (centerX, centerY, radius, angleInDegrees) => {
+        var angleInRadians = ((angleInDegrees - 90) * Math.PI) / 180.0;
+        return {
+            x: centerX + radius * Math.cos(angleInRadians),
+            y: centerY + radius * Math.sin(angleInRadians),
+        };
+    };
+    circlePath = (x, y, radius, startAngle, endAngle) => {
+        var start = this.polarToCartesian(x, y, radius, endAngle * 0.9999);
+        var end = this.polarToCartesian(x, y, radius, startAngle);
+        var largeArcFlag = endAngle - startAngle <= 180 ? "0" : "1";
+        var d = [
+            "M",
+            start.x,
+            start.y,
+            "A",
+            radius,
+            radius,
+            0,
+            largeArcFlag,
+            0,
+            end.x,
+            end.y,
+        ];
+        return d.join(" ");
+    };
+    clampFill = (fill) => Math.min(100, Math.max(0, fill));
+    render() {
+        const { size, width, backgroundWidth, tintColor = "black", tintTransparency = true, backgroundColor, style, rotation = 90, lineCap = "butt", arcSweepAngle = 360, fill, children, childrenContainerStyle, padding = 0, renderCap, dashedBackground = { width: 0, gap: 0 }, dashedTint = { width: 0, gap: 0 }, } = this.props;
+        const maxWidthCircle = backgroundWidth
+            ? Math.max(width, backgroundWidth)
+            : width;
+        const sizeWithPadding = size / 2 + padding / 2;
+        const radius = size / 2 - maxWidthCircle / 2 - padding / 2;
+        const currentFillAngle = (arcSweepAngle * this.clampFill(fill)) / 100;
+        const backgroundPath = this.circlePath(sizeWithPadding, sizeWithPadding, radius, tintTransparency ? 0 : currentFillAngle, arcSweepAngle);
+        const circlePathItem = this.circlePath(sizeWithPadding, sizeWithPadding, radius, 0, currentFillAngle);
+        const coordinate = this.polarToCartesian(sizeWithPadding, sizeWithPadding, radius, currentFillAngle);
+        const cap = renderCap ? renderCap({ center: coordinate }) : null;
+        const offset = size - maxWidthCircle * 2;
+        const localChildrenContainerStyle = [
+            {
+                position: "absolute",
+                left: maxWidthCircle + padding / 2,
+                top: maxWidthCircle + padding / 2,
+                width: offset,
+                height: offset,
+                borderRadius: offset / 2,
+                alignItems: "center",
+                justifyContent: "center",
+                overflow: "hidden",
+            },
+            childrenContainerStyle,
+        ];
+        const strokeDasharrayTint = dashedTint.gap > 0
+            ? Object.values(dashedTint)
+                .map((value) => value.toString())
+                .join(" ")
+            : "";
+        const strokeDasharrayBackground = dashedBackground.gap > 0
+            ? Object.values(dashedBackground)
+                .map((value) => value.toString())
+                .join(" ")
+            : "";
+        return (React.createElement(View, { style: style },
+            React.createElement(Svg, { width: size + padding, height: size + padding },
+                React.createElement(G, { rotation: rotation, originX: (size + padding) / 2, originY: (size + padding) / 2 },
+                    backgroundColor && (React.createElement(Path, { d: backgroundPath, stroke: backgroundColor, strokeWidth: backgroundWidth || width, strokeLinecap: lineCap, strokeDasharray: strokeDasharrayBackground, fill: "transparent" })),
+                    fill > 0 && (React.createElement(Path, { d: circlePathItem, stroke: tintColor, strokeWidth: width, strokeLinecap: lineCap, strokeDasharray: strokeDasharrayTint, fill: "transparent" })),
+                    cap)),
+            children && (React.createElement(View, { style: localChildrenContainerStyle }, children(fill)))));
+    }
+}
+export default CircularProgress;

package/src/components/Config.js

@@ -0,0 +1,63 @@
+import { Dimensions, Platform } from "react-native";
+const getWindowDimensions = () => {
+    const { width, height } = Dimensions.get("window");
+    return {
+        windowWidth: width,
+        windowHeight: height,
+    };
+};
+const { windowWidth, windowHeight } = getWindowDimensions();
+const getFilters = (options) => {
+    const { width, height } = options;
+    const filters = ["c_scale", "q_auto", "dpr_auto"];
+    if (width)
+        filters.push(`w_${width}`);
+    if (height)
+        filters.push(`h_${height}`);
+    return filters.join(",");
+};
+const buildImageUrl = (options, name) => {
+    const filters = getFilters(options);
+    return [
+        "https://res.cloudinary.com/altos/image/upload",
+        filters,
+        `${name}.png`,
+    ].join("/");
+};
+const getExtension = () => {
+    return Platform.OS === "web" ? ".svg" : ".png";
+};
+export default {
+    windowWidth,
+    windowHeight,
+    avatarImageUrl: buildImageUrl({
+        width: 60,
+        height: 60,
+    }, "Avatar"),
+    avatarImageSize: 60,
+    cardImageSize: 200,
+    cardImageUrl: "https://static.draftbit.com/images/placeholder-image" + getExtension(),
+    cardIconSize: 16,
+    cardIconBackgroundOpacity: 0.24,
+    cardIconElevation: 1,
+    placeholderImageURL: "https://static.draftbit.com/images/placeholder-image" + getExtension(),
+    getPlaceholderImageUrl: (size) => buildImageUrl({ width: size.width, height: size.height }, "image-placeholder_1"),
+    squareImageUrl: buildImageUrl({ width: 100, height: 100 }, "Avatar"),
+    FABSize: 40,
+    FABBorderRadius: 20,
+    FABFixedHeight: 64,
+    cardContainerShortImageAspectRatio: 1,
+    rowSingleLineImageSize: 24,
+    rowMultiLineImageSize: 48,
+    rowSingleLineIconSize: 24,
+    rowMultiLineIconSize: 16,
+    headerIconSize: 24,
+    buttonIconSize: 24,
+    swiperInactiveDotSize: 6,
+    swiperActiveDotSize: 10,
+    fieldSearchBarFullIconSize: 24,
+    stepperButtonSize: 40,
+    radioButtonSize: 24,
+    topSafeAreaViewHeight: 0,
+    // topSafeAreaViewHeight: Platform.OS === "android" ? Constants.statusBarHeight : 0
+};

package/src/components/Container.js

@@ -0,0 +1,73 @@
+import * as React from "react";
+import { View, ImageBackground, StyleSheet, } from "react-native";
+import { withTheme } from "../theming";
+import Elevation from "./Elevation";
+import { GROUPS, COMPONENT_TYPES, FORM_TYPES, PROP_TYPES, createElevationType, createImageProp, createResizeModeProp, } from "@draftbit/types";
+const Container = ({ useThemeGutterPadding, borderColor, borderWidth, backgroundColor, backgroundImage, backgroundImageResizeMode, elevation, style, children, theme, // eslint-disable-line @typescript-eslint/no-unused-vars
+...rest }) => {
+    const { flex, flexGrow, flexWrap, flexBasis, flexShrink, flexDirection, alignContent, justifyContent, alignItems, padding, paddingTop, paddingBottom, paddingLeft, paddingRight, paddingVertical, paddingHorizontal, ...styleProp } = StyleSheet.flatten(style) || {};
+    const containerStyle = {
+        backgroundColor,
+        borderColor,
+        borderWidth,
+        width: "100%",
+        ...styleProp,
+    };
+    const innerStyle = {
+        flex,
+        flexGrow,
+        flexWrap,
+        flexBasis,
+        flexShrink,
+        flexDirection,
+        alignContent,
+        justifyContent,
+        alignItems,
+        padding,
+        paddingTop,
+        paddingBottom,
+        paddingLeft,
+        paddingRight,
+        paddingVertical,
+        paddingHorizontal: paddingHorizontal || useThemeGutterPadding ? 16 : 0,
+    };
+    const Wrap = elevation ? Elevation : View;
+    if (elevation) {
+        containerStyle.elevation = elevation;
+    }
+    return (React.createElement(Wrap, { style: [containerStyle, style], ...rest }, backgroundImage ? (React.createElement(ImageBackground, { source: typeof backgroundImage === "string"
+            ? { uri: backgroundImage }
+            : backgroundImage, resizeMode: backgroundImageResizeMode, style: {
+            flex: 1,
+        } },
+        React.createElement(View, { style: innerStyle }, children))) : (React.createElement(View, { style: innerStyle }, children))));
+};
+export default withTheme(Container);
+export const SEED_DATA = {
+    name: "Container",
+    tag: "Container",
+    description: "A container component with gutter padding",
+    category: COMPONENT_TYPES.deprecated,
+    layout: {
+        height: 250,
+    },
+    props: {
+        useThemeGutterPadding: {
+            group: GROUPS.basic,
+            label: "Use gutter padding",
+            description: "When true, uses the theme gutter spacing as the container's horizontal padding",
+            formType: FORM_TYPES.boolean,
+            propType: PROP_TYPES.BOOLEAN,
+            defaultValue: false,
+            editable: false,
+            required: true,
+        },
+        backgroundImage: createImageProp({
+            label: "Background Image",
+            description: "Apply a custom background image",
+            defaultValue: null,
+        }),
+        backgroundImageResizeMode: createResizeModeProp(),
+        elevation: createElevationType(0),
+    },
+};