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

package/src/components/StepIndicator.js

@@ -0,0 +1,346 @@
+// @ts-nocheck
+import React, { Component } from "react";
+import { View, Text, StyleSheet, Animated, TouchableWithoutFeedback, } from "react-native";
+const STEP_STATUS = {
+    CURRENT: "current",
+    FINISHED: "finished",
+    UNFINISHED: "unfinished",
+};
+export default class StepIndicator extends Component {
+    constructor(props) {
+        super(props);
+        const defaultStyles = {
+            stepIndicatorSize: 30,
+            currentStepIndicatorSize: 40,
+            separatorStrokeWidth: 3,
+            separatorStrokeUnfinishedWidth: 0,
+            separatorStrokeFinishedWidth: 0,
+            currentStepStrokeWidth: 5,
+            stepStrokeWidth: 0,
+            stepStrokeCurrentColor: "#4aae4f",
+            stepStrokeFinishedColor: "#4aae4f",
+            stepStrokeUnFinishedColor: "#4aae4f",
+            separatorFinishedColor: "#4aae4f",
+            separatorUnFinishedColor: "#a4d4a5",
+            stepIndicatorFinishedColor: "#4aae4f",
+            stepIndicatorUnFinishedColor: "#a4d4a5",
+            stepIndicatorCurrentColor: "#ffffff",
+            stepIndicatorLabelFontSize: 15,
+            currentStepIndicatorLabelFontSize: 15,
+            stepIndicatorLabelCurrentColor: "#000000",
+            stepIndicatorLabelFinishedColor: "#ffffff",
+            stepIndicatorLabelUnFinishedColor: "rgba(255,255,255,0.5)",
+            labelColor: "#000000",
+            labelSize: 13,
+            labelAlign: "center",
+            currentStepLabelColor: "#4aae4f",
+        };
+        const customStyles = Object.assign(defaultStyles, props.customStyles);
+        this.state = {
+            width: 0,
+            height: 1,
+            progressBarSize: -2,
+            customStyles,
+        };
+        this.progressAnim = new Animated.Value(0);
+        this.sizeAnim = new Animated.Value(this.state.customStyles.stepIndicatorSize);
+        this.borderRadiusAnim = new Animated.Value(this.state.customStyles.stepIndicatorSize / 2);
+    }
+    stepPressed(position) {
+        if (this.props.onPress) {
+            this.props.onPress(position);
+        }
+    }
+    render() {
+        const { labels, direction } = this.props;
+        return (React.createElement(View, { style: [
+                styles.container,
+                direction === "vertical"
+                    ? { flexDirection: "row", flex: 1 }
+                    : { flexDirection: "column" },
+            ] },
+            this.state.width !== 0 && this.renderProgressBarBackground(),
+            this.state.width !== 0 && this.renderProgressBar(),
+            this.renderStepIndicator(),
+            labels && this.renderStepLabels()));
+    }
+    componentDidUpdate(prevProps) {
+        // if (prevProps.customStyles !== this.props.customStyles) {
+        //   this.setState((state) => ({
+        //     customStyles: Object.assign(
+        //       state.customStyles,
+        //       this.props.customStyles
+        //     ),
+        //   }));
+        // }
+        if (prevProps.currentPosition !== this.props.currentPosition) {
+            this.onCurrentPositionChanged(this.props.currentPosition);
+        }
+    }
+    renderProgressBarBackground = () => {
+        const { stepCount, direction } = this.props;
+        let progressBarBackgroundStyle;
+        if (direction === "vertical") {
+            progressBarBackgroundStyle = {
+                backgroundColor: this.state.customStyles.separatorUnFinishedColor,
+                position: "absolute",
+                left: (this.state.width - this.state.customStyles.separatorStrokeWidth) / 2,
+                top: this.state.height / (2 * stepCount),
+                bottom: this.state.height / (2 * stepCount),
+                width: this.state.customStyles.separatorStrokeUnfinishedWidth === 0
+                    ? this.state.customStyles.separatorStrokeWidth
+                    : this.state.customStyles.separatorStrokeUnfinishedWidth,
+            };
+        }
+        else {
+            progressBarBackgroundStyle = {
+                backgroundColor: this.state.customStyles.separatorUnFinishedColor,
+                position: "absolute",
+                top: (this.state.height - this.state.customStyles.separatorStrokeWidth) /
+                    2,
+                left: this.state.width / (2 * stepCount),
+                right: this.state.width / (2 * stepCount),
+                height: this.state.customStyles.separatorStrokeUnfinishedWidth === 0
+                    ? this.state.customStyles.separatorStrokeWidth
+                    : this.state.customStyles.separatorStrokeUnfinishedWidth,
+            };
+        }
+        return (React.createElement(View, { onLayout: (event) => {
+                if (direction === "vertical") {
+                    this.setState({ progressBarSize: event.nativeEvent.layout.height }, () => {
+                        this.onCurrentPositionChanged(this.props.currentPosition);
+                    });
+                }
+                else {
+                    this.setState({ progressBarSize: event.nativeEvent.layout.width }, () => {
+                        this.onCurrentPositionChanged(this.props.currentPosition);
+                    });
+                }
+            }, style: progressBarBackgroundStyle }));
+    };
+    renderProgressBar = () => {
+        const { stepCount, direction } = this.props;
+        let progressBarStyle;
+        if (direction === "vertical") {
+            progressBarStyle = {
+                backgroundColor: this.state.customStyles.separatorFinishedColor,
+                position: "absolute",
+                left: (this.state.width - this.state.customStyles.separatorStrokeWidth) / 2,
+                top: this.state.height / (2 * stepCount),
+                bottom: this.state.height / (2 * stepCount),
+                width: this.state.customStyles.separatorStrokeFinishedWidth === 0
+                    ? this.state.customStyles.separatorStrokeWidth
+                    : this.state.customStyles.separatorStrokeFinishedWidth,
+                height: this.progressAnim,
+            };
+        }
+        else {
+            progressBarStyle = {
+                backgroundColor: this.state.customStyles.separatorFinishedColor,
+                position: "absolute",
+                top: (this.state.height - this.state.customStyles.separatorStrokeWidth) /
+                    2,
+                left: this.state.width / (2 * stepCount),
+                right: this.state.width / (2 * stepCount),
+                height: this.state.customStyles.separatorStrokeFinishedWidth === 0
+                    ? this.state.customStyles.separatorStrokeWidth
+                    : this.state.customStyles.separatorStrokeFinishedWidth,
+                width: this.progressAnim,
+            };
+        }
+        return React.createElement(Animated.View, { style: progressBarStyle });
+    };
+    renderStepIndicator = () => {
+        let steps = [];
+        const { stepCount, direction } = this.props;
+        for (let position = 0; position < stepCount; position++) {
+            steps.push(React.createElement(TouchableWithoutFeedback, { key: position, onPress: () => this.stepPressed(position) },
+                React.createElement(View, { style: [
+                        styles.stepContainer,
+                        direction === "vertical"
+                            ? { flexDirection: "column" }
+                            : { flexDirection: "row" },
+                    ] }, this.renderStep(position))));
+        }
+        return (React.createElement(View, { onLayout: (event) => this.setState({
+                width: event.nativeEvent.layout.width,
+                height: event.nativeEvent.layout.height,
+            }), style: [
+                styles.stepIndicatorContainer,
+                direction === "vertical"
+                    ? {
+                        flexDirection: "column",
+                        width: this.state.customStyles.currentStepIndicatorSize,
+                    }
+                    : {
+                        flexDirection: "row",
+                        height: this.state.customStyles.currentStepIndicatorSize,
+                    },
+            ] }, steps));
+    };
+    renderStepLabels = () => {
+        const { labels, direction, currentPosition, renderLabel } = this.props;
+        var labelViews = labels.map((label, index) => {
+            const selectedStepLabelStyle = index === currentPosition
+                ? { color: this.state.customStyles.currentStepLabelColor }
+                : { color: this.state.customStyles.labelColor };
+            return (React.createElement(TouchableWithoutFeedback, { style: styles.stepLabelItem, key: index, onPress: () => this.stepPressed(index) },
+                React.createElement(View, { style: styles.stepLabelItem }, renderLabel ? (renderLabel({
+                    position: index,
+                    stepStatus: this.getStepStatus(index),
+                    label,
+                    currentPosition,
+                })) : (React.createElement(Text, { style: [
+                        styles.stepLabel,
+                        selectedStepLabelStyle,
+                        {
+                            fontSize: this.state.customStyles.labelSize,
+                            fontFamily: this.state.customStyles.labelFontFamily,
+                        },
+                    ] }, label)))));
+        });
+        return (React.createElement(View, { style: [
+                styles.stepLabelsContainer,
+                direction === "vertical"
+                    ? { flexDirection: "column", paddingHorizontal: 4 }
+                    : { flexDirection: "row", paddingVertical: 4 },
+                { alignItems: this.state.customStyles.labelAlign },
+            ] }, labelViews));
+    };
+    renderStep = (position) => {
+        const { renderStepIndicator } = this.props;
+        let stepStyle;
+        let indicatorLabelStyle;
+        switch (this.getStepStatus(position)) {
+            case STEP_STATUS.CURRENT: {
+                stepStyle = {
+                    backgroundColor: this.state.customStyles.stepIndicatorCurrentColor,
+                    borderWidth: this.state.customStyles.currentStepStrokeWidth,
+                    borderColor: this.state.customStyles.stepStrokeCurrentColor,
+                    height: this.sizeAnim,
+                    width: this.sizeAnim,
+                    borderRadius: this.borderRadiusAnim,
+                };
+                indicatorLabelStyle = {
+                    fontSize: this.state.customStyles.currentStepIndicatorLabelFontSize,
+                    color: this.state.customStyles.stepIndicatorLabelCurrentColor,
+                };
+                break;
+            }
+            case STEP_STATUS.FINISHED: {
+                stepStyle = {
+                    backgroundColor: this.state.customStyles.stepIndicatorFinishedColor,
+                    borderWidth: this.state.customStyles.stepStrokeWidth,
+                    borderColor: this.state.customStyles.stepStrokeFinishedColor,
+                    height: this.state.customStyles.stepIndicatorSize,
+                    width: this.state.customStyles.stepIndicatorSize,
+                    borderRadius: this.state.customStyles.stepIndicatorSize / 2,
+                };
+                indicatorLabelStyle = {
+                    fontSize: this.state.customStyles.stepIndicatorLabelFontSize,
+                    color: this.state.customStyles.stepIndicatorLabelFinishedColor,
+                };
+                break;
+            }
+            case STEP_STATUS.UNFINISHED: {
+                stepStyle = {
+                    backgroundColor: this.state.customStyles.stepIndicatorUnFinishedColor,
+                    borderWidth: this.state.customStyles.stepStrokeWidth,
+                    borderColor: this.state.customStyles.stepStrokeUnFinishedColor,
+                    height: this.state.customStyles.stepIndicatorSize,
+                    width: this.state.customStyles.stepIndicatorSize,
+                    borderRadius: this.state.customStyles.stepIndicatorSize / 2,
+                };
+                indicatorLabelStyle = {
+                    overflow: "hidden",
+                    fontSize: this.state.customStyles.stepIndicatorLabelFontSize,
+                    color: this.state.customStyles.stepIndicatorLabelUnFinishedColor,
+                };
+                break;
+            }
+            default:
+        }
+        return (React.createElement(Animated.View, { key: "step-indicator", style: [styles.step, stepStyle] }, renderStepIndicator ? (renderStepIndicator({
+            position,
+            stepStatus: this.getStepStatus(position),
+        })) : (React.createElement(Text, { style: indicatorLabelStyle }, `${position + 1}`))));
+    };
+    getStepStatus = (stepPosition) => {
+        const { currentPosition } = this.props;
+        if (stepPosition === currentPosition) {
+            return STEP_STATUS.CURRENT;
+        }
+        else if (stepPosition < currentPosition) {
+            return STEP_STATUS.FINISHED;
+        }
+        else {
+            return STEP_STATUS.UNFINISHED;
+        }
+    };
+    onCurrentPositionChanged = (position) => {
+        let { stepCount } = this.props;
+        if (position > stepCount - 1) {
+            position = stepCount - 1;
+        }
+        const animateToPosition = (this.state.progressBarSize / (stepCount - 1)) * position;
+        this.sizeAnim.setValue(this.state.customStyles.stepIndicatorSize);
+        this.borderRadiusAnim.setValue(this.state.customStyles.stepIndicatorSize / 2);
+        Animated.sequence([
+            Animated.timing(this.progressAnim, {
+                toValue: animateToPosition,
+                duration: 200,
+            }),
+            Animated.parallel([
+                Animated.timing(this.sizeAnim, {
+                    toValue: this.state.customStyles.currentStepIndicatorSize,
+                    duration: 100,
+                }),
+                Animated.timing(this.borderRadiusAnim, {
+                    toValue: this.state.customStyles.currentStepIndicatorSize / 2,
+                    duration: 100,
+                }),
+            ]),
+        ]).start();
+    };
+}
+const styles = StyleSheet.create({
+    container: {
+        backgroundColor: "transparent",
+    },
+    stepIndicatorContainer: {
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "space-around",
+        backgroundColor: "transparent",
+    },
+    stepLabelsContainer: {
+        justifyContent: "space-around",
+    },
+    step: {
+        alignItems: "center",
+        justifyContent: "center",
+        zIndex: 2,
+    },
+    stepContainer: {
+        flex: 1,
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "center",
+    },
+    stepLabel: {
+        fontSize: 12,
+        textAlign: "center",
+        fontWeight: "500",
+    },
+    stepLabelItem: {
+        flex: 1,
+        alignItems: "center",
+        justifyContent: "center",
+    },
+});
+StepIndicator.defaultProps = {
+    currentPosition: 0,
+    stepCount: 5,
+    customStyles: {},
+    direction: "horizontal",
+};

package/src/components/Stepper.js

@@ -0,0 +1,69 @@
+import * as React from "react";
+import { View, Text } from "react-native";
+import { withTheme } from "../theming";
+import { COMPONENT_TYPES, createIconSizeProp, createColorProp, createFieldNameProp, Triggers, } from "@draftbit/types";
+import IconButton from "./IconButton";
+import { usePrevious } from "../hooks";
+const Stepper = ({ Icon, value = 0, style, onChange, initialValue, theme: { colors, typography, roundness }, iconSize = 24, iconColor = colors.strong, borderRadius = roundness, typeStyle, }) => {
+    const [stateValue, setStateValue] = React.useState(value);
+    const previousInitialValue = usePrevious(initialValue);
+    React.useEffect(() => {
+        if (initialValue !== previousInitialValue) {
+            setStateValue(initialValue);
+            onChange && onChange(initialValue);
+        }
+    }, [initialValue, previousInitialValue, onChange, setStateValue]);
+    const handleMinus = () => {
+        if (value || value === 0) {
+            onChange && onChange(value - 1);
+        }
+        else {
+            setStateValue(stateValue - 1);
+        }
+    };
+    const handlePlus = () => {
+        if (value || value === 0) {
+            onChange && onChange(value + 1);
+        }
+        else {
+            setStateValue(stateValue + 1);
+        }
+    };
+    return (React.createElement(View, { style: [
+            { flexDirection: "row" },
+            style,
+            borderRadius ? { borderRadius } : {},
+        ] },
+        React.createElement(IconButton, { Icon: Icon, icon: "MaterialIcons/remove", onPress: handleMinus, size: iconSize, color: iconColor, disabled: value ? value === 0 : stateValue === 0 }),
+        React.createElement(Text, { style: [
+                typography.body1,
+                {
+                    textAlign: "center",
+                    alignSelf: "center",
+                    color: colors.medium,
+                    marginHorizontal: 8,
+                },
+                typeStyle,
+            ] }, value || stateValue),
+        React.createElement(IconButton, { Icon: Icon, icon: "MaterialIcons/add", onPress: handlePlus, size: iconSize, color: iconColor })));
+};
+export default withTheme(Stepper);
+export const SEED_DATA = [
+    {
+        name: "Stepper",
+        tag: "Stepper",
+        description: "A component used to control the quantity of something",
+        category: COMPONENT_TYPES.input,
+        layout: {},
+        triggers: [Triggers.OnChange],
+        props: {
+            fieldName: createFieldNameProp({
+                defaultValue: "stepperValue",
+                handlerPropName: "onChange",
+                valuePropName: "value",
+            }),
+            iconSize: createIconSizeProp({ defaultValue: 24 }),
+            iconColor: createColorProp({ defaultValue: "strong" }),
+        },
+    },
+];

package/src/components/Surface.js

@@ -0,0 +1,36 @@
+/* Copied from https://github.com/callstack/react-native-paper/blob/main/src/components/Surface.tsx */
+import * as React from "react";
+import { Animated, StyleSheet, View, } from "react-native";
+import shadow from "../styles/shadow";
+import overlay from "../styles/overlay";
+import { withTheme } from "../theming";
+import { COMPONENT_TYPES, createElevationType } from "@draftbit/types";
+const Surface = ({ elevation, style, theme, children, ...rest }) => {
+    const { elevation: styleElevation = 3, borderRadius: radius = 0 } = (StyleSheet.flatten(style) || {});
+    const { dark: isDarkTheme, mode, colors } = theme;
+    const borderRadius = radius;
+    const ele = elevation || styleElevation;
+    return (React.createElement(Animated.View, { ...rest, style: [
+            {
+                minHeight: 40,
+                borderRadius,
+                backgroundColor: isDarkTheme && mode === "adaptive"
+                    ? overlay(ele, colors.surface)
+                    : colors.surface,
+            },
+            elevation ? shadow(elevation) : null,
+            style,
+        ] },
+        React.createElement(View, { style: { overflow: "hidden", borderRadius } }, children)));
+};
+export default withTheme(Surface);
+export const SEED_DATA = {
+    name: "Surface",
+    tag: "Surface",
+    description: "An elevated container",
+    category: COMPONENT_TYPES.layout,
+    layout: {},
+    props: {
+        elevation: createElevationType(0),
+    },
+};

package/src/components/Switch.js

@@ -0,0 +1,59 @@
+import * as React from "react";
+import { Switch as NativeSwitch, } from "react-native";
+import { withTheme } from "../theming";
+import FormRow from "./FormRow";
+import { RowDirection } from "@draftbit/types";
+import { usePrevious } from "../hooks";
+function Switch({ value = false, initialValue, disabled, onValueChange, activeTrackColor, inactiveTrackColor, activeThumbColor, inactiveThumbColor, theme, style, ...rest }) {
+    const activeTrackThemeColor = activeTrackColor || theme.colors.primary;
+    const inactiveTrackThemeColor = inactiveTrackColor || "#EEE";
+    const activeThumbThemeColor = activeThumbColor || "#FFF";
+    const inactiveThumbThemeColor = inactiveThumbColor || "#FFF";
+    const [checked, setChecked] = React.useState(value);
+    React.useEffect(() => {
+        if (value !== checked) {
+            setChecked(value);
+        }
+    }, [value, checked]);
+    const booleanInitialValue = Boolean(initialValue);
+    const previousInitialValue = usePrevious(booleanInitialValue);
+    React.useEffect(() => {
+        if (initialValue != null && booleanInitialValue !== previousInitialValue) {
+            setChecked(booleanInitialValue);
+            onValueChange && onValueChange(booleanInitialValue);
+        }
+    }, [
+        initialValue,
+        booleanInitialValue,
+        previousInitialValue,
+        setChecked,
+        onValueChange,
+    ]);
+    return (React.createElement(NativeSwitch, { value: checked, disabled: disabled, trackColor: {
+            false: inactiveTrackThemeColor,
+            true: activeTrackThemeColor,
+        }, thumbColor: value ? activeThumbThemeColor : inactiveThumbThemeColor, 
+        // @ts-ignore react-native-web only
+        activeThumbColor: activeThumbThemeColor, ios_backgroundColor: inactiveTrackThemeColor, style: style, onValueChange: (bool) => {
+            setChecked(bool);
+            onValueChange && onValueChange(bool);
+        }, ...rest }));
+}
+function Row({ label = "Label", direction = RowDirection.Row, style, value = false, disabled, onValueChange, activeTrackColor, inactiveTrackColor, activeThumbColor, inactiveThumbColor, theme, ...rest }) {
+    const [checked, setChecked] = React.useState(value);
+    React.useEffect(() => {
+        if (value !== checked) {
+            setChecked(value);
+        }
+    }, [value, checked]);
+    return (React.createElement(FormRow, { disabled: disabled, onPress: () => {
+            setChecked(!checked);
+            onValueChange && onValueChange(!checked);
+        }, label: label, direction: direction, style: style, ...rest },
+        React.createElement(Switch, { theme: theme, value: checked, disabled: disabled, onValueChange: onValueChange, activeTrackColor: activeTrackColor, inactiveTrackColor: inactiveTrackColor, activeThumbColor: activeThumbColor, inactiveThumbColor: inactiveThumbColor })));
+}
+const SwitchRow = withTheme(Row);
+export { SwitchRow };
+export default withTheme(Switch);
+/* README: SEED_DATA lives inside mappings/Switch.js since there were weird issues taking place with sourceMaps being
+ * generated */