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

package/src/components/DatePicker/DatePicker.js

@@ -0,0 +1,379 @@
+import * as React from "react";
+import { View, Animated, Text, StyleSheet, Platform, I18nManager, TextInput as NativeTextInput, } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import dateFormat from "dateformat";
+import { withTheme } from "../../theming";
+import Portal from "../Portal/Portal";
+import Button from "../DeprecatedButton";
+import Touchable from "../Touchable";
+import DateTimePicker from "./DatePickerComponent";
+import { usePrevious } from "../../hooks";
+const AnimatedText = Animated.createAnimatedComponent(Text);
+const FOCUS_ANIMATION_DURATION = 150;
+const BLUR_ANIMATION_DURATION = 180;
+const ICON_SIZE = 24;
+const MONTHS = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+];
+const DatePicker = ({ Icon, style, theme: { colors, typography, roundness, disabledOpacity }, date, onDateChange = () => { }, initialValue, disabled = false, mode = "date", format, type = "underline", leftIconName, rightIconName, leftIconMode = "inset", label, placeholder, ...props }) => {
+    const [value, setValue] = React.useState(date);
+    const [pickerVisible, setPickerVisible] = React.useState(false);
+    const [labeled] = React.useState(new Animated.Value(date ? 0 : 1));
+    const [placeholder1, setPlaceholder1] = React.useState("");
+    const [focused, setFocused] = React.useState(false);
+    const [labelLayout, setLabelLayout] = React.useState({ measured: false, width: 0 });
+    const previousInitialValue = usePrevious(initialValue);
+    React.useEffect(() => {
+        const initialValueStr = initialValue ? initialValue.toString() : "";
+        const previousInitialValueStr = previousInitialValue
+            ? // This weirdly complains about being possibly undefined despite being inside a ternary
+                // @ts-ignore
+                previousInitialValue.toString()
+            : "";
+        if (initialValueStr !== previousInitialValueStr) {
+            setValue(initialValue);
+            onDateChange(initialValue);
+        }
+    }, [initialValue, previousInitialValue, setValue, onDateChange]);
+    const getValidDate = () => {
+        if (!value) {
+            return new Date();
+        }
+        return typeof value?.getMonth === "function" ? value : new Date();
+    };
+    const formatDate = () => {
+        if (!value)
+            return "";
+        let newDate = getValidDate();
+        if (format)
+            return dateFormat(newDate, format);
+        if (mode === "time") {
+            return `${newDate.toLocaleTimeString()}`;
+        }
+        if (mode === "datetime") {
+            return `${newDate.toLocaleString()}`;
+        }
+        return `${MONTHS[newDate.getMonth()]} ${newDate.getDate()}, ${newDate.getFullYear()}`;
+    };
+    const toggleVisibility = async () => {
+        setPickerVisible(!pickerVisible);
+        focused ? _handleBlur() : _handleFocus();
+    };
+    const insets = useSafeAreaInsets();
+    // const _restoreLabel = () =>
+    //   Animated.timing(labeled, {
+    //     toValue: 1,
+    //     duration: FOCUS_ANIMATION_DURATION,
+    //     useNativeDriver: true,
+    //   }).start();
+    // const _minmizeLabel = () =>
+    //   Animated.timing(labeled, {
+    //     toValue: 0,
+    //     duration: BLUR_ANIMATION_DURATION,
+    //     useNativeDriver: true,
+    //   }).start();
+    // const _showPlaceholder = () =>
+    //   setTimeout(() => setPlaceholder1(placeholder || ""), 50);
+    const _hidePlaceholder = () => {
+        setPlaceholder1("");
+    };
+    React.useEffect(() => {
+        setValue(date);
+    }, [date]);
+    React.useEffect(() => {
+        if (value || focused || placeholder1) {
+            // _minmizeLabel();
+            Animated.timing(labeled, {
+                toValue: 0,
+                duration: BLUR_ANIMATION_DURATION,
+                useNativeDriver: true,
+            }).start();
+        }
+        else {
+            // _restoreLabel();
+            Animated.timing(labeled, {
+                toValue: 1,
+                duration: FOCUS_ANIMATION_DURATION,
+                useNativeDriver: true,
+            }).start();
+        }
+    }, [value, focused, placeholder1, labeled]);
+    React.useEffect(() => {
+        const _showPlaceholder = () => setTimeout(() => setPlaceholder1(placeholder || ""), 50);
+        if (focused || !label) {
+            _showPlaceholder();
+        }
+        else {
+            _hidePlaceholder();
+        }
+        return () => {
+            clearTimeout(_showPlaceholder());
+        };
+    }, [focused, label, placeholder]);
+    const _handleFocus = () => {
+        if (disabled) {
+            return;
+        }
+        setFocused(true);
+    };
+    const _handleBlur = () => {
+        if (disabled) {
+            return;
+        }
+        setFocused(false);
+    };
+    const MINIMIZED_LABEL_Y_OFFSET = -(typography.caption.lineHeight + 4);
+    const OUTLINE_MINIMIZED_LABEL_Y_OFFSET = -(16 * 0.5 + 4);
+    const MAXIMIZED_LABEL_FONT_SIZE = typography.subtitle1.fontSize;
+    const MINIMIZED_LABEL_FONT_SIZE = typography.caption.fontSize;
+    const hasActiveOutline = focused;
+    let inputTextColor, activeColor, underlineColor, borderColor, placeholderColor, containerStyle, backgroundColor, inputStyle;
+    inputTextColor = colors.strong;
+    if (disabled) {
+        activeColor = colors.light;
+        placeholderColor = colors.light;
+        borderColor = "transparent";
+        underlineColor = "transparent";
+        backgroundColor = colors.divider;
+    }
+    else {
+        activeColor = colors.primary;
+        placeholderColor = borderColor = colors.light;
+        underlineColor = colors.light;
+        backgroundColor = colors.background;
+    }
+    const { lineHeight, ...subtitle1 } = typography.subtitle1;
+    inputStyle = {
+        paddingVertical: 0,
+        color: inputTextColor,
+        paddingLeft: leftIconName && leftIconMode === "inset"
+            ? ICON_SIZE + (type === "solid" ? 16 : 12)
+            : 0,
+        paddingRight: rightIconName ? ICON_SIZE + 16 + 4 : 12,
+        ...subtitle1,
+        height: lineHeight,
+    };
+    if (type === "underline") {
+        containerStyle = {
+            borderTopLeftRadius: roundness,
+            borderTopRightRadius: roundness,
+            paddingBottom: 12,
+            marginTop: 16,
+        };
+    }
+    else {
+        containerStyle = {
+            borderRadius: roundness,
+            borderColor: hasActiveOutline ? activeColor : borderColor,
+            borderWidth: 1,
+            paddingTop: labeled ? 16 * 1.5 : 16,
+            paddingBottom: labeled ? 16 * 0.5 : 16,
+            opacity: disabled ? disabledOpacity : 1,
+            backgroundColor,
+        };
+        inputStyle.paddingHorizontal = 12;
+    }
+    if (leftIconName && leftIconMode === "outset") {
+        containerStyle.marginLeft = ICON_SIZE + 8;
+    }
+    let leftIconColor;
+    if (focused) {
+        leftIconColor = colors.primary;
+    }
+    else {
+        leftIconColor = colors.light;
+    }
+    const leftIconProps = {
+        size: 24,
+        color: leftIconColor,
+        name: leftIconName || "",
+    };
+    const leftIconStyle = {
+        position: "absolute",
+        marginTop: type === "solid"
+            ? leftIconMode === "inset"
+                ? MINIMIZED_LABEL_FONT_SIZE + 4
+                : 16
+            : leftIconMode === "outset"
+                ? 16
+                : 0,
+    };
+    const labelStyle = {
+        ...typography.subtitle1,
+        top: type === "solid" ? 16 : 0,
+        left: leftIconName && leftIconMode === "inset"
+            ? ICON_SIZE + (type === "solid" ? 16 : 12)
+            : 0,
+        transform: [
+            {
+                // Move label to top
+                translateY: labeled.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [
+                        type === "solid"
+                            ? OUTLINE_MINIMIZED_LABEL_Y_OFFSET
+                            : MINIMIZED_LABEL_Y_OFFSET,
+                        0,
+                    ],
+                }),
+            },
+            {
+                // Make label smaller
+                scale: labeled.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [
+                        MINIMIZED_LABEL_FONT_SIZE / MAXIMIZED_LABEL_FONT_SIZE,
+                        1,
+                    ],
+                }),
+            },
+            {
+                // Offset label scale since RN doesn't support transform origin
+                translateX: labeled.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [
+                        -(1 - MINIMIZED_LABEL_FONT_SIZE / MAXIMIZED_LABEL_FONT_SIZE) *
+                            (labelLayout.width / 2),
+                        0,
+                    ],
+                }),
+            },
+        ],
+    };
+    const inputStyles = [
+        styles.input,
+        inputStyle,
+        type === "solid" ? { marginHorizontal: 12 } : {},
+    ];
+    // const render = (props) => <NativeTextInput {...props} />;
+    return (React.createElement(View, { style: [styles.container, style] },
+        React.createElement(Touchable, { disabled: disabled, onPress: toggleVisibility },
+            React.createElement(View, { pointerEvents: "none" },
+                React.createElement(View, { style: [styles.container, style] },
+                    leftIconName && leftIconMode === "outset" ? (React.createElement(Icon, { ...leftIconProps, style: leftIconStyle })) : null,
+                    React.createElement(View, { style: [containerStyle, style ? { height: style.height } : {}] },
+                        type === "underline" ? (
+                        // When type === 'flat', render an underline
+                        React.createElement(Animated.View, { style: [
+                                styles.underline,
+                                {
+                                    backgroundColor: focused ? activeColor : underlineColor,
+                                    // Underlines is thinner when input is not focused
+                                    transform: [{ scaleY: focused ? 1 : 0.5 }],
+                                },
+                            ] })) : null,
+                        label ? (
+                        // Position colored placeholder and gray placeholder on top of each other and crossfade them
+                        // This gives the effect of animating the color, but allows us to use native driver
+                        React.createElement(View, { pointerEvents: "none", style: [
+                                StyleSheet.absoluteFill,
+                                {
+                                    opacity: 
+                                    // Hide the label in minimized state until we measure its width
+                                    date || focused ? (labelLayout.measured ? 1 : 0) : 1,
+                                },
+                            ] },
+                            React.createElement(AnimatedText, { onLayout: (e) => setLabelLayout({
+                                    width: e.nativeEvent.layout.width,
+                                    measured: true,
+                                }), style: [
+                                    styles.placeholder,
+                                    type === "solid" ? { paddingHorizontal: 12 } : {},
+                                    labelStyle,
+                                    {
+                                        color: colors.light,
+                                        opacity: labeled.interpolate({
+                                            inputRange: [0, 1],
+                                            outputRange: [hasActiveOutline ? 1 : 0, 0],
+                                        }),
+                                    },
+                                ], numberOfLines: 1 }, label),
+                            React.createElement(AnimatedText, { style: [
+                                    styles.placeholder,
+                                    type === "solid" ? { paddingHorizontal: 12 } : {},
+                                    labelStyle,
+                                    {
+                                        color: placeholderColor,
+                                        opacity: hasActiveOutline ? labeled : 1,
+                                    },
+                                ], numberOfLines: 1 }, label))) : null,
+                        leftIconName && leftIconMode === "inset" ? (React.createElement(Icon, { ...leftIconProps, style: {
+                                ...leftIconStyle,
+                                marginLeft: type === "solid" ? 16 : 0,
+                            } })) : null,
+                        React.createElement(NativeTextInput, { value: formatDate(), placeholder: label ? placeholder1 : placeholder, editable: !disabled, placeholderTextColor: placeholderColor, selectionColor: activeColor, onFocus: _handleFocus, onBlur: _handleBlur, underlineColorAndroid: "transparent", style: inputStyles, ...props })),
+                    rightIconName ? (React.createElement(Icon, { name: rightIconName, size: ICON_SIZE, color: colors.light, style: {
+                            position: "absolute",
+                            right: 16,
+                            marginTop: type === "solid" ? MINIMIZED_LABEL_FONT_SIZE + 4 : 16,
+                        } })) : null))),
+        pickerVisible && (React.createElement(Portal, null,
+            React.createElement(View, { style: [
+                    styles.picker,
+                    {
+                        backgroundColor: colors.divider,
+                    },
+                ] },
+                React.createElement(View, { style: [
+                        styles.pickerContainer,
+                        {
+                            paddingTop: insets.top,
+                            paddingBottom: insets.bottom,
+                            paddingLeft: insets.left,
+                            paddingRight: insets.right,
+                        },
+                    ] },
+                    Platform.OS === "ios" && (React.createElement(Button, { Icon: Icon, type: "text", onPress: toggleVisibility, style: styles.closeButton }, "Close")),
+                    React.createElement(DateTimePicker, { value: getValidDate(), mode: mode, isVisible: pickerVisible, toggleVisibility: toggleVisibility, onChange: (_event, data) => {
+                            Platform.OS === "ios" ? null : toggleVisibility();
+                            setValue(data);
+                            onDateChange(data);
+                        } })))))));
+};
+const styles = StyleSheet.create({
+    container: {
+        alignSelf: "stretch",
+    },
+    picker: {
+        position: "absolute",
+        bottom: 0,
+        left: 0,
+        right: 0,
+        flexDirection: "row",
+        justifyContent: "center",
+    },
+    underline: {
+        position: "absolute",
+        left: 0,
+        right: 0,
+        bottom: 0,
+        height: 2,
+    },
+    input: {
+        flexGrow: 1,
+        justifyContent: "center",
+        textAlignVertical: "center",
+        margin: 0,
+        textAlign: I18nManager.isRTL ? "right" : "left",
+    },
+    placeholder: {
+        position: "absolute",
+        left: 0,
+    },
+    pickerContainer: { flexDirection: "column", width: "100%" },
+    closeButton: {
+        alignSelf: "flex-end",
+    },
+});
+export default withTheme(DatePicker);

package/src/components/DatePicker/DatePicker.tsx

@@ -104,7 +104,13 @@ const DatePicker: React.FC<Props> = ({
 
   const previousInitialValue = usePrevious(initialValue);
   React.useEffect(() => {
-    if (initialValue !== previousInitialValue) {
+    const initialValueStr = initialValue ? initialValue.toString() : "";
+    const previousInitialValueStr = previousInitialValue
+      ? // This weirdly complains about being possibly undefined despite being inside a ternary
+        // @ts-ignore
+        previousInitialValue.toString()
+      : "";
+    if (initialValueStr !== previousInitialValueStr) {
       setValue(initialValue);
       onDateChange(initialValue);
     }

package/src/components/DatePicker/DatePickerComponent.js

@@ -0,0 +1,13 @@
+import React from "react";
+import { Platform } from "react-native";
+import DateTimePicker from "@react-native-community/datetimepicker";
+import DateTimePickerModal from "react-native-modal-datetime-picker";
+const DatePickerComponent = ({ value, onChange, mode, toggleVisibility, }) => {
+    return Platform.OS === "ios" || Platform.OS === "android" ? (React.createElement(DateTimePickerModal, { date: value, mode: mode, isVisible: true, display: Platform.OS === "ios" ? "spinner" : "default", onCancel: () => {
+            console.log("Picker cancelled before selecting anything.");
+            toggleVisibility();
+        }, onConfirm: (data) => {
+            onChange(null, data);
+        } })) : (React.createElement(DateTimePicker, { value: value, mode: mode, onChange: onChange, display: "default" }));
+};
+export default DatePickerComponent;

package/src/components/DatePicker/DatePickerComponent.web.js

@@ -0,0 +1,30 @@
+import React from "react";
+import DateFnsUtils from "@date-io/date-fns";
+import { MuiPickersUtilsProvider, DatePicker, TimePicker, DateTimePicker, } from "@material-ui/pickers";
+import { createMuiTheme, ThemeProvider } from "@material-ui/core/styles";
+import { withTheme } from "../../theming";
+import Theme from "../../styles/DefaultTheme";
+const DatePickerComponent = ({ value, onChange, mode, toggleVisibility, isVisible, theme, }) => {
+    const internalTheme = createMuiTheme({
+        palette: {
+            primary: {
+                main: theme?.colors?.primary ?? Theme.colors.primary,
+            },
+            secondary: {
+                main: theme?.colors?.secondary ?? Theme.colors.secondary,
+            },
+        },
+    });
+    const Picker = mode === "date"
+        ? DatePicker
+        : mode === "time"
+            ? TimePicker
+            : DateTimePicker;
+    return (React.createElement(MuiPickersUtilsProvider, { utils: DateFnsUtils },
+        React.createElement(ThemeProvider, { theme: internalTheme },
+            React.createElement(Picker, { value: value, open: isVisible, onChange: (d) => {
+                    toggleVisibility();
+                    onChange(null, d);
+                }, onClose: () => toggleVisibility(), variant: "dialog", TextFieldComponent: () => null }))));
+};
+export default withTheme(DatePickerComponent);

package/src/components/DatePicker/DatePickerComponentType.js

@@ -0,0 +1 @@
+export {};

package/src/components/DeprecatedButton.js

@@ -0,0 +1,201 @@
+import * as React from "react";
+import { ActivityIndicator, View, Text, StyleSheet, } from "react-native";
+import color from "color";
+import Config from "./Config";
+import Touchable from "./Touchable";
+import Elevation from "./Elevation";
+import { withTheme } from "../theming";
+import { GROUPS, FORM_TYPES, PROP_TYPES, COMPONENT_TYPES, createActionProp, Triggers, } from "@draftbit/types";
+const Button = ({ Icon, icon, disabled = false, type = "solid", loading = false, labelColor, color: colorOverride, children, onPress, elevation = 0, style, theme: { colors, disabledOpacity, roundness, typography }, ...rest }) => {
+    let backgroundColor, borderColor, textColor, borderWidth;
+    const buttonColor = colorOverride || colors.primary;
+    if (type === "solid") {
+        backgroundColor = buttonColor;
+        if (disabled) {
+            textColor = color(colors.surface).alpha(disabledOpacity).rgb().string();
+        }
+        else {
+            textColor = labelColor || colors.surface;
+        }
+    }
+    else {
+        backgroundColor = "transparent";
+        if (disabled) {
+            textColor = color(buttonColor).alpha(disabledOpacity).rgb().string();
+        }
+        else {
+            textColor = labelColor || buttonColor;
+        }
+    }
+    if (type === "outline") {
+        if (disabled) {
+            borderColor = color(buttonColor).alpha(disabledOpacity).rgb().string();
+        }
+        else {
+            borderColor = buttonColor;
+        }
+        borderWidth = StyleSheet.hairlineWidth;
+    }
+    else {
+        borderColor = "transparent";
+        borderWidth = 0;
+    }
+    const buttonStyle = {
+        backgroundColor,
+        borderColor,
+        borderWidth,
+        borderRadius: roundness,
+    };
+    const textStyle = {
+        textAlign: "center",
+        color: textColor,
+        marginVertical: 16,
+        marginHorizontal: 16,
+    };
+    const iconStyle = [
+        styles.icon,
+        {
+            marginLeft: 16,
+            marginRight: -8,
+            width: Config.buttonIconSize,
+        },
+    ];
+    const { margin, marginEnd, marginTop, marginLeft, marginRight, marginBottom, marginHorizontal, marginVertical, ...innerStyles } = StyleSheet.flatten(style || {});
+    const margins = {
+        margin,
+        marginEnd,
+        marginTop,
+        marginLeft,
+        marginRight,
+        marginBottom,
+        marginHorizontal,
+        marginVertical,
+    };
+    return (React.createElement(Elevation, { style: { elevation, alignSelf: "stretch", ...margins } },
+        React.createElement(Touchable, { ...rest, onPress: onPress, accessibilityState: { disabled }, accessibilityRole: "button", disabled: disabled || loading, style: [styles.button, buttonStyle, innerStyles] },
+            React.createElement(View, { style: styles.content },
+                icon && loading !== true ? (React.createElement(View, { style: iconStyle },
+                    React.createElement(Icon, { name: icon, size: Config.buttonIconSize, color: textColor }))) : null,
+                loading ? (React.createElement(ActivityIndicator, { size: "small", color: textColor, style: iconStyle })) : null,
+                React.createElement(Text, { numberOfLines: 1, style: [textStyle, typography.button] }, children)))));
+};
+const styles = StyleSheet.create({
+    button: {
+        minWidth: 64,
+        borderStyle: "solid",
+    },
+    content: {
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "center",
+    },
+    icon: {
+        width: Config.buttonIconSize,
+    },
+});
+export default withTheme(Button);
+const SEED_DATA_PROPS = {
+    onPress: createActionProp(),
+    icon: {
+        group: GROUPS.basic,
+        label: "Icon Name",
+        description: "Name of the icon",
+        editable: true,
+        required: true,
+        formType: FORM_TYPES.icon,
+        propType: PROP_TYPES.STRING,
+        defaultValue: null,
+    },
+    children: {
+        group: GROUPS.data,
+        label: "Label",
+        description: "Button label",
+        required: true,
+        editable: true,
+        formType: FORM_TYPES.string,
+        propType: PROP_TYPES.STRING,
+        defaultValue: "Get Started",
+    },
+    color: {
+        group: GROUPS.basic,
+        label: "Color Override",
+        description: "Override the background color of the button",
+        editable: true,
+        required: false,
+        formType: FORM_TYPES.color,
+        propType: PROP_TYPES.THEME,
+        defaultValue: null,
+    },
+    labelColor: {
+        group: GROUPS.basic,
+        label: "Label Color Override",
+        description: "Override the label color of the button",
+        editable: true,
+        required: false,
+        formType: FORM_TYPES.color,
+        propType: PROP_TYPES.THEME,
+        defaultValue: null,
+    },
+    disabled: {
+        group: GROUPS.basic,
+        label: "Disabled",
+        description: "Whether the button should be disabled",
+        editable: true,
+        required: false,
+        formType: FORM_TYPES.boolean,
+        propType: PROP_TYPES.BOOLEAN,
+        defaultValue: null,
+    },
+    loading: {
+        group: GROUPS.data,
+        label: "Loading",
+        description: "Whether to show a loading indicator",
+        editable: true,
+        required: false,
+        formType: FORM_TYPES.boolean,
+        propType: PROP_TYPES.BOOLEAN,
+        defaultValue: null,
+    },
+};
+export const SEED_DATA = [
+    {
+        name: "Button Outline",
+        tag: "Button",
+        category: COMPONENT_TYPES.deprecated,
+        triggers: [Triggers.OnPress],
+        props: {
+            ...SEED_DATA_PROPS,
+            type: {
+                group: GROUPS.uncategorized,
+                label: "Type",
+                description: "Button type",
+                editable: false,
+                required: true,
+                formType: FORM_TYPES.string,
+                propType: PROP_TYPES.STRING,
+                defaultValue: "outline",
+            },
+        },
+        layout: {},
+    },
+    {
+        name: "Button Solid",
+        tag: "Button",
+        category: COMPONENT_TYPES.deprecated,
+        triggers: [Triggers.OnPress],
+        props: {
+            ...SEED_DATA_PROPS,
+            type: {
+                group: GROUPS.uncategorized,
+                label: "Type",
+                description: "Button type",
+                editable: false,
+                required: true,
+                formType: FORM_TYPES.string,
+                propType: PROP_TYPES.STRING,
+                defaultValue: "solid",
+            },
+        },
+        layout: {},
+    },
+];

package/src/components/DeprecatedCardWrapper.js

@@ -0,0 +1,18 @@
+import React from "react";
+import { withTheme } from "../theming";
+import Touchable from "./Touchable";
+const getWidth = (numColumns) => {
+    switch (numColumns) {
+        case 1:
+            return "33%";
+        case 2:
+            return "50%";
+        default:
+            return "100%";
+    }
+};
+const Card = ({ numColumns = 3, children, onPress, style, ...rest }) => {
+    const width = getWidth(numColumns);
+    return (React.createElement(Touchable, { disabled: !onPress, onPress: onPress, style: [style, { width }], ...rest }, children));
+};
+export default withTheme(Card);