@jobber/components-native 0.38.0 → 0.38.1-migrate-au.2

package/dist/src/AtlantisContext/AtlantisContext.js

@@ -3,6 +3,7 @@ import { createContext, useContext } from "react";
 import RNLocalize from "react-native-localize";
 import { DEFAULT_CURRENCY_SYMBOL } from "../InputCurrency/constants";
 export const defaultValues = {
+    dateFormat: "PP",
     // The system time is "p"
     timeFormat: "p",
     timeZone: RNLocalize.getTimeZone(),
@@ -12,6 +13,7 @@ export const defaultValues = {
     },
     floatSeparators: { group: ",", decimal: "." },
     currencySymbol: DEFAULT_CURRENCY_SYMBOL,
+    headerHeight: 0,
 };
 export const AtlantisContext = createContext(defaultValues);
 export function useAtlantisContext() {

package/dist/src/AutoLink/AutoLink.js

@@ -0,0 +1,23 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from "react";
+import { Text as RNText } from "react-native";
+import { ComposeTextWithLinks } from "./components";
+import { useCreateLinkedText } from "./hooks/useCreateLinkedText";
+import { TypographyGestureDetector } from "../Typography";
+import { tokens } from "../utils/design";
+export function AutoLink(_a) {
+    var { children: text = "", bottomTabsVisible = true, selectable = true } = _a, rest = __rest(_a, ["children", "bottomTabsVisible", "selectable"]);
+    const { splitText, matches } = useCreateLinkedText(Object.assign({ text }, rest));
+    return (React.createElement(TypographyGestureDetector, null,
+        React.createElement(RNText, { selectable: selectable, selectionColor: tokens["color-brand--highlight"] }, splitText.map((part, index) => (React.createElement(ComposeTextWithLinks, { key: index, part: part, index: index, match: matches[part], bottomTabsVisible: bottomTabsVisible, selectable: selectable }))))));
+}

package/dist/src/AutoLink/components/ComposeTextWithLinks/ComposeTextWithLinks.js

@@ -0,0 +1,19 @@
+import React from "react";
+import { useIntl } from "react-intl";
+import { Platform } from "react-native";
+import { onLongPressLink, onPressLink } from "../../utils";
+import { Link } from "../Link/Link";
+import { Text } from "../../../Text";
+export function ComposeTextWithLinks({ part, index, match, bottomTabsVisible, selectable = true, }) {
+    const { formatMessage } = useIntl();
+    const isLink = match === null || match === void 0 ? void 0 : match.getType();
+    if (isLink) {
+        return (React.createElement(Link, { key: index, onPress: () => onPressLink(match), onLongPress: () => {
+                if (selectable && Platform.OS === "android") {
+                    return;
+                }
+                onLongPressLink(match, bottomTabsVisible, formatMessage);
+            } }, match.getAnchorText()));
+    }
+    return React.createElement(Text, { key: index }, part);
+}

package/dist/src/AutoLink/components/Link/Link.js

@@ -0,0 +1,8 @@
+import React from "react";
+// eslint-disable-next-line no-restricted-imports
+import { Text as RNText } from "react-native";
+import { Text } from "../../../Text";
+export function Link({ children, onPress, onLongPress, }) {
+    return (React.createElement(RNText, { onPress: onPress, onLongPress: onLongPress },
+        React.createElement(Text, { variation: "interactive" }, children)));
+}

package/dist/src/AutoLink/components/index.js

@@ -0,0 +1,2 @@
+export { Link } from "./Link/Link";
+export { ComposeTextWithLinks } from "./ComposeTextWithLinks/ComposeTextWithLinks";

package/dist/src/AutoLink/hooks/useCreateLinkedText.js

@@ -0,0 +1,24 @@
+import Autolinker from "autolinker";
+import { useTokenGenerator } from "./useTokenGenerator";
+import { shouldIgnoreURL } from "../utils";
+export function useCreateLinkedText({ text = "", email = true, phone = true, urls = true, }) {
+    const [generateToken, tokenRegexp] = useTokenGenerator();
+    const matches = {};
+    const linkedText = Autolinker.link(text, {
+        email,
+        phone,
+        urls,
+        replaceFn: match => {
+            if (shouldIgnoreURL(text, match))
+                return false;
+            const token = generateToken();
+            matches[token] = match;
+            return token;
+        },
+    });
+    const splitText = splitLinkedText(linkedText, tokenRegexp);
+    return { splitText, matches };
+}
+function splitLinkedText(linkedText, tokenRegexp) {
+    return linkedText.split(tokenRegexp).filter(part => Boolean(part));
+}

package/dist/src/AutoLink/hooks/useTokenGenerator.js

@@ -0,0 +1,10 @@
+import { useState } from "react";
+import { v1 } from "react-native-uuid";
+export function useTokenGenerator() {
+    let counter = 0;
+    const [identifier] = useState(v1());
+    return [
+        () => `@__ELEMENT-${identifier}-${counter++}__@`,
+        new RegExp(`(@__ELEMENT-${identifier}-\\d+__@)`, "g"),
+    ];
+}

package/dist/src/AutoLink/index.js

@@ -0,0 +1 @@
+export * from "./AutoLink";

package/dist/src/AutoLink/messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from "react-intl";
+export const messages = defineMessages({
+    phoneCopied: {
+        id: "phoneCopied",
+        defaultMessage: "Phone number copied",
+        description: "Message shown after copying a phone number",
+    },
+    emailCopied: {
+        id: "emailCopied",
+        defaultMessage: "Email copied",
+        description: "Message shown after copying an email",
+    },
+    urlCopied: {
+        id: "urlCopied",
+        defaultMessage: "URL copied",
+        description: "Message shown after copying a URL",
+    },
+});

package/dist/src/AutoLink/types.js

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

package/dist/src/AutoLink/utils.js

@@ -0,0 +1,53 @@
+import Clipboard from "@react-native-clipboard/clipboard";
+import { Linking } from "react-native";
+import { messages } from "./messages";
+import { showToast } from "../Toast";
+function hasPrefix(text, prefixes) {
+    return prefixes.some(prefix => text.includes(prefix));
+}
+export function shouldIgnoreURL(text, match) {
+    const matchedText = match.getMatchedText().toLocaleLowerCase();
+    const urlPrefixes = ["http://", "https://", "www."];
+    const ignorePrefixes = ["file://", "ftp://"];
+    const previousChar = text.charAt(match.getOffset() - 1);
+    if (match.getType() === "url") {
+        const hasUrlPrefix = hasPrefix(matchedText, urlPrefixes);
+        const hasIgnorePrefix = hasPrefix(matchedText, ignorePrefixes) || previousChar === "/";
+        return hasIgnorePrefix && !hasUrlPrefix;
+    }
+    return false;
+}
+export function getUrl(match, immediateOpen = true) {
+    const matchType = match.getType();
+    switch (matchType) {
+        case "email":
+            return immediateOpen
+                ? `mailto:${encodeURIComponent(match.getEmail())}`
+                : match.getEmail();
+        case "phone":
+            return immediateOpen
+                ? `tel:${match.getNumber()}`
+                : match.getNumber();
+        default:
+            return match.getAnchorHref();
+    }
+}
+export function copyTextToClipboard(text, toastConfig) {
+    Clipboard.setString(text);
+    if (toastConfig) {
+        const { message, bottomTabsVisible } = toastConfig;
+        showToast({ message, bottomTabsVisible });
+    }
+}
+export function onLongPressLink(match, bottomTabsVisible, formatMessage) {
+    const linkUrl = getUrl(match, false);
+    const toastConfig = {
+        message: formatMessage(messages[`${match.getType()}Copied`]),
+        bottomTabsVisible,
+    };
+    copyTextToClipboard(linkUrl, toastConfig);
+}
+export function onPressLink(match) {
+    const linkUrl = getUrl(match);
+    Linking.openURL(linkUrl);
+}

package/dist/src/Form/Form.js

@@ -0,0 +1,187 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { useState } from "react";
+import { FormProvider } from "react-hook-form";
+import { KeyboardAwareScrollView } from "react-native-keyboard-aware-scroll-view";
+import { Keyboard, Platform, View, findNodeHandle, } from "react-native";
+import { styles } from "./Form.style";
+import { FormErrorBanner } from "./components/FormErrorBanner";
+import { KEYBOARD_SAVE_BUTTON_DISTANCE } from "./constants";
+import { FormMessageBanner } from "./components/FormMessageBanner";
+import { FormSubmitErrorType, } from "./types";
+import { FormMask } from "./components/FormMask";
+import { useInternalForm } from "./hooks/useInternalForm";
+import { useFormViewRefs } from "./hooks/useFormViewRefs";
+import { useScreenInformation } from "./hooks/useScreenInformation";
+import { FormMessage } from "./components/FormMessage";
+import { FormBody, useBottomPadding } from "./components/FormBody";
+import { useOfflineHandler } from "./hooks/useOfflineHandler";
+import { useScrollToError } from "./hooks/useScrollToError";
+import { FormSaveButton } from "./components/FormSaveButton";
+import { useSaveButtonPosition } from "./hooks/useSaveButtonPosition";
+import { FormCache } from "./components/FormCache/FormCache";
+import { InputAccessoriesProvider } from "../InputText";
+import { tokens } from "../utils/design";
+import { ErrorMessageProvider } from "../ErrorMessageWrapper";
+export function Form(_a) {
+    var { initialLoading } = _a, rest = __rest(_a, ["initialLoading"]);
+    const child = initialLoading ? React.createElement(FormMask, null) : React.createElement(InternalForm, Object.assign({}, rest));
+    return (React.createElement(InputAccessoriesProvider, null,
+        React.createElement(ErrorMessageProvider, null, child)));
+}
+// eslint-disable-next-line max-statements
+function InternalForm({ children, onBeforeSubmit, onSubmit, onSubmitError, onSubmitSuccess, bannerErrors, bannerMessages, initialValues, mode = "onTouched", reValidateMode = "onChange", formRef, saveButtonLabel, renderStickySection, localCacheKey, localCacheExclude, localCacheId, secondaryActions, saveButtonOffset, showStickySaveButton = false, renderFooter, }) {
+    var _a;
+    const { scrollViewRef, bottomViewRef, scrollToTop } = useFormViewRefs();
+    const [saveButtonHeight, setSaveButtonHeight] = useState(0);
+    const [messageBannerHeight, setMessageBannerHeight] = useState(0);
+    const { formMethods, handleSubmit, isSubmitting, removeListenerRef, setLocalCache, } = useInternalForm({
+        mode,
+        reValidateMode,
+        initialValues,
+        formRef,
+        localCacheKey,
+        localCacheExclude,
+        localCacheId,
+        scrollViewRef,
+        saveButtonHeight,
+        messageBannerHeight,
+    });
+    const { windowHeight, headerHeight } = useScreenInformation();
+    const [keyboardHeight, setKeyboardHeight] = useState(0);
+    const [keyboardScreenY, setKeyboardScreenY] = useState(0);
+    const [formContentHeight, setFormContentHeight] = useState(0);
+    const [isBottomSheetOpen, setIsBottomSheetOpen] = useState(false);
+    const paddingBottom = useBottomPadding();
+    const { saveButtonPosition } = useSaveButtonPosition({
+        formContentHeight,
+        isBottomSheetOpen,
+        showStickySaveButton,
+        keyboardHeight,
+        keyboardScreenY,
+    });
+    const [isSecondaryActionLoading, setIsSecondaryActionLoading] = useState(false);
+    const extraViewHeight = paddingBottom + KEYBOARD_SAVE_BUTTON_DISTANCE;
+    const calculatedKeyboardHeight = keyboardHeight - extraViewHeight;
+    useScrollToError({
+        formState: formMethods.formState,
+        refNode: findNodeHandle(scrollViewRef.current),
+        setFocus: formMethods.setFocus,
+        scrollToPosition: (_a = scrollViewRef.current) === null || _a === void 0 ? void 0 : _a.scrollToPosition,
+    });
+    const handleOfflineSubmit = useOfflineHandler();
+    const keyboardProps = Platform.select({
+        ios: {
+            onKeyboardWillHide: handleKeyboardHide,
+            onKeyboardWillShow: handleKeyboardShow,
+        },
+        android: {
+            onKeyboardDidHide: handleKeyboardHide,
+            onKeyboardDidShow: handleKeyboardShow,
+        },
+    });
+    const onLayout = (event) => {
+        setMessageBannerHeight(event.nativeEvent.layout.height);
+    };
+    return (React.createElement(FormProvider, Object.assign({}, formMethods),
+        React.createElement(React.Fragment, null,
+            (isSubmitting || isSecondaryActionLoading) && React.createElement(FormMask, null),
+            React.createElement(FormCache, { localCacheKey: localCacheKey, localCacheExclude: localCacheExclude, setLocalCache: setLocalCache }),
+            React.createElement(FormBody, { keyboardHeight: calculateSaveButtonOffset(), submit: handleSubmit(internalSubmit), isFormSubmitting: isSubmitting, saveButtonLabel: saveButtonLabel, shouldRenderActionBar: saveButtonPosition === "sticky", renderStickySection: renderStickySection, secondaryActions: secondaryActions, setSecondaryActionLoading: setIsSecondaryActionLoading, setSaveButtonHeight: setSaveButtonHeight, saveButtonOffset: saveButtonOffset },
+                React.createElement(KeyboardAwareScrollView, Object.assign({ enableResetScrollToCoords: false, enableAutomaticScroll: true, keyboardOpeningTime: Platform.OS === "ios" ? tokens["timing-slowest"] : 0, keyboardShouldPersistTaps: "handled", ref: scrollViewRef }, keyboardProps, { extraHeight: headerHeight, contentContainerStyle: !keyboardHeight && styles.scrollContentContainer }),
+                    React.createElement(View, { onLayout: ({ nativeEvent }) => {
+                            setFormContentHeight(nativeEvent.layout.height);
+                        } },
+                        React.createElement(View, { onLayout: onLayout },
+                            React.createElement(FormMessageBanner, { bannerMessages: bannerMessages }),
+                            React.createElement(FormErrorBanner, { networkError: bannerErrors === null || bannerErrors === void 0 ? void 0 : bannerErrors.networkError, bannerError: bannerErrors === null || bannerErrors === void 0 ? void 0 : bannerErrors.bannerError })),
+                        React.createElement(View, { style: styles.formChildContainer },
+                            React.createElement(React.Fragment, null,
+                                React.createElement(View, { style: styles.formContent }, children),
+                                saveButtonPosition === "inline" && (React.createElement(View, { style: styles.fixedSaveButton }, renderStickySection ? (renderStickySection(handleSubmit(internalSubmit), saveButtonLabel, isSubmitting)) : (React.createElement(FormSaveButton, { primaryAction: handleSubmit(internalSubmit), label: saveButtonLabel, loading: isSubmitting, secondaryActions: secondaryActions, setSecondaryActionLoading: setIsSecondaryActionLoading, onOpenBottomSheet: () => setIsBottomSheetOpen(true), onCloseBottomSheet: () => setIsBottomSheetOpen(false) })))),
+                                renderFooter))),
+                    React.createElement(View, { style: styles.safeArea, ref: bottomViewRef })))),
+        React.createElement(FormMessage, null)));
+    function handleKeyboardShow(frames) {
+        setKeyboardScreenY(frames.endCoordinates.screenY);
+        setKeyboardHeight(frames.endCoordinates.height);
+    }
+    function handleKeyboardHide() {
+        var _a;
+        (_a = bottomViewRef === null || bottomViewRef === void 0 ? void 0 : bottomViewRef.current) === null || _a === void 0 ? void 0 : _a.measureInWindow(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        (_x, y, _width, _height) => {
+            var _a;
+            // This fixes extra whitespace below the form if it was scrolled down while the keyboard was open
+            // i.e. a View below the form is higher than the bottom of the window
+            if (y < windowHeight) {
+                (_a = scrollViewRef === null || scrollViewRef === void 0 ? void 0 : scrollViewRef.current) === null || _a === void 0 ? void 0 : _a.scrollToEnd();
+            }
+        });
+        setKeyboardHeight(0);
+        setKeyboardScreenY(0);
+    }
+    function internalSubmit(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let performSubmit = true;
+            if (onBeforeSubmit) {
+                performSubmit = yield onBeforeSubmit(data);
+            }
+            if (performSubmit) {
+                Keyboard.dismiss();
+                return onSubmit(data)
+                    .then((result) => {
+                    var _a;
+                    (_a = removeListenerRef.current) === null || _a === void 0 ? void 0 : _a.call(removeListenerRef);
+                    onSubmitSuccess(result);
+                })
+                    .catch(handleSubmitCatch);
+            }
+        });
+    }
+    function handleSubmitCatch(error) {
+        // Scroll to top of form to see error
+        scrollToTop();
+        onSubmitError(error);
+        if ((error === null || error === void 0 ? void 0 : error.errorType) === FormSubmitErrorType.NetworkError) {
+            // @ts-expect-error We are making the form submission fail so that we can
+            // prevent the isSubmitSuccess to be true
+            formMethods.setError("offline", "Error saving form.");
+            handleOfflineSubmit(handleRetry, clearFormErrors)();
+        }
+    }
+    function clearFormErrors() {
+        // @ts-expect-error  We are clearing the error that we previously set
+        // when the form had no internet connection
+        formMethods.clearErrors("offline");
+    }
+    function handleRetry() {
+        clearFormErrors();
+        return handleSubmit(internalSubmit)();
+    }
+    function calculateSaveButtonOffset() {
+        if (saveButtonOffset) {
+            // Included the space-base because it's the padding of the FormActionBar
+            return calculatedKeyboardHeight - saveButtonOffset + tokens["space-base"];
+        }
+        return calculatedKeyboardHeight;
+    }
+}

package/dist/src/Form/Form.style.js

@@ -0,0 +1,33 @@
+import { StyleSheet } from "react-native";
+import { tokens } from "../utils/design";
+export const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        flexGrow: 1,
+        width: "100%",
+    },
+    safeArea: {
+        backgroundColor: tokens["color-surface"],
+    },
+    scrollContentContainer: {
+        flexGrow: 1,
+    },
+    scrollView: {
+        flexGrow: 1,
+    },
+    formChildContainer: {
+        flexGrow: 1,
+        justifyContent: "flex-start",
+    },
+    formContent: {
+        paddingVertical: tokens["space-small"],
+    },
+    fixedSaveButton: {
+        padding: tokens["space-base"],
+        backgroundColor: tokens["color-surface"],
+    },
+    activityIndicator: {
+        marginVertical: tokens["space-base"],
+        flex: 1,
+    },
+});

package/dist/src/Form/components/FormActionBar/FormActionBar.js

@@ -0,0 +1,21 @@
+import React from "react";
+import { StyleSheet, View } from "react-native";
+import Reanimated from "react-native-reanimated";
+import { styles } from "./FormActionBar.style";
+import { FormSaveButton } from "../FormSaveButton";
+const ReanimatedView = Reanimated.createAnimatedComponent(View);
+export function FormActionBar({ keyboardHeight, submit, isFormSubmitting, saveButtonLabel, renderStickySection, setSaveButtonHeight, secondaryActions, setSecondaryActionLoading, }) {
+    const buttonStyle = StyleSheet.flatten([
+        styles.saveButton,
+        {
+            position: keyboardHeight > 0 ? "absolute" : "relative",
+            bottom: 0,
+        },
+    ]);
+    const onLayout = (event) => {
+        setSaveButtonHeight && setSaveButtonHeight(event.nativeEvent.layout.height);
+    };
+    return (
+    //@ts-expect-error tsc-ci
+    React.createElement(ReanimatedView, { style: buttonStyle, onLayout: onLayout }, renderStickySection ? (renderStickySection(submit, saveButtonLabel, isFormSubmitting)) : (React.createElement(FormSaveButton, { setSecondaryActionLoading: setSecondaryActionLoading, primaryAction: submit, loading: isFormSubmitting, label: saveButtonLabel, secondaryActions: secondaryActions }))));
+}

package/dist/src/Form/components/FormActionBar/FormActionBar.style.js

@@ -0,0 +1,5 @@
+import { StyleSheet } from "react-native";
+import { tokens } from "../../../utils/design";
+export const styles = StyleSheet.create({
+    saveButton: Object.assign({ padding: tokens["space-base"], backgroundColor: tokens["color-surface"], width: "100%" }, tokens["shadow-high"]),
+});

package/dist/src/Form/components/FormActionBar/index.js

@@ -0,0 +1 @@
+export { FormActionBar } from "./FormActionBar";

package/dist/src/Form/components/FormBody/FormBody.js

@@ -0,0 +1,20 @@
+import React, { useMemo } from "react";
+import { View } from "react-native";
+import { styles } from "./FormBody.style";
+import { useScreenInformation } from "../../hooks/useScreenInformation";
+import { FormActionBar } from "../FormActionBar";
+import { tokens } from "../../../utils/design";
+export function FormBody({ isFormSubmitting, submit, keyboardHeight, children, saveButtonLabel, renderStickySection, shouldRenderActionBar = true, secondaryActions, setSecondaryActionLoading, setSaveButtonHeight, saveButtonOffset, }) {
+    const paddingBottom = useBottomPadding();
+    const fullViewPadding = useMemo(() => ({ paddingBottom }), [paddingBottom]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(View, { style: [styles.container] },
+            children,
+            shouldRenderActionBar && (React.createElement(FormActionBar, { setSecondaryActionLoading: setSecondaryActionLoading, keyboardHeight: keyboardHeight, submit: submit, isFormSubmitting: isFormSubmitting, saveButtonLabel: saveButtonLabel, renderStickySection: renderStickySection, secondaryActions: secondaryActions, setSaveButtonHeight: setSaveButtonHeight }))),
+        shouldRenderActionBar && !saveButtonOffset && (React.createElement(View, { style: [fullViewPadding, styles.safeArea], testID: "ATL-FormSafeArea" }))));
+}
+export function useBottomPadding() {
+    const { insets } = useScreenInformation();
+    const extraBottomSpace = insets.bottom - tokens["space-base"];
+    return extraBottomSpace >= 0 ? extraBottomSpace : 0;
+}

package/dist/src/Form/components/FormBody/FormBody.style.js

@@ -0,0 +1,26 @@
+import { StyleSheet } from "react-native";
+import { tokens } from "../../../utils/design";
+export const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        flexGrow: 1,
+        width: "100%",
+    },
+    safeArea: {
+        backgroundColor: tokens["color-surface"],
+    },
+    scrollContentContainer: {
+        flexGrow: 1,
+    },
+    scrollView: {
+        flexGrow: 1,
+    },
+    formChildContainer: {
+        flexGrow: 1,
+        justifyContent: "flex-start",
+    },
+    activityIndicator: {
+        marginVertical: tokens["space-base"],
+        flex: 1,
+    },
+});

package/dist/src/Form/components/FormBody/index.js

@@ -0,0 +1 @@
+export { FormBody, useBottomPadding } from "./FormBody";

package/dist/src/Form/components/FormCache/FormCache.js

@@ -0,0 +1,34 @@
+import React, { useEffect, useMemo } from "react";
+import { useFormContext, useWatch } from "react-hook-form";
+import omit from "lodash/omit";
+export function FormCache({ localCacheExclude, localCacheKey, setLocalCache, }) {
+    const { control, formState } = useFormContext();
+    const { isDirty } = formState;
+    const formData = useWatch({ control });
+    const shouldExclude = useMemo(() => {
+        return Array.isArray(localCacheExclude) && localCacheExclude.length > 0;
+    }, [localCacheExclude]);
+    useEffect(() => {
+        !localCacheKey &&
+            console.log("No `localCacheKey` specified on Form. Local copy of form data is now disabled.");
+    }, [localCacheKey]);
+    /**
+     * Automatically save form data locally
+     */
+    useEffect(() => {
+        if (!isDirty)
+            return;
+        if (shouldExclude) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore The type below is not working. It seems to be an issue with react-hook-form
+            // https://github.com/react-hook-form/react-hook-form/issues/2978
+            setLocalCache(omit(formData, localCacheExclude));
+        }
+        else {
+            // @ts-expect-error Typescript thinks that the FieldValues defined in useWatch is different
+            // from the one in useFormContext
+            setLocalCache(formData);
+        }
+    }, [formData, isDirty, localCacheExclude, setLocalCache, shouldExclude]);
+    return React.createElement(React.Fragment, null);
+}

package/dist/src/Form/components/FormErrorBanner/FormErrorBanner.js

@@ -0,0 +1,21 @@
+import React from "react";
+import { useIntl } from "react-intl";
+import { messages } from "./messages";
+import { useAtlantisContext } from "../../../AtlantisContext";
+import { Banner } from "../../../Banner";
+export function FormErrorBanner({ networkError, bannerError, }) {
+    const { formatMessage } = useIntl();
+    const { isOnline } = useAtlantisContext();
+    if (!isOnline) {
+        return (React.createElement(Banner, { text: formatMessage(messages.offlineError), type: "error" }));
+    }
+    else if (networkError) {
+        return (React.createElement(Banner, { text: formatMessage(messages.networkError), type: "error" }));
+    }
+    else if (bannerError) {
+        return (React.createElement(Banner, { text: bannerError.title, details: bannerError.messages, type: "error" }));
+    }
+    else {
+        return React.createElement(React.Fragment, null);
+    }
+}

package/dist/src/Form/components/FormErrorBanner/index.js

@@ -0,0 +1 @@
+export { FormErrorBanner } from "./FormErrorBanner";

package/dist/src/Form/components/FormErrorBanner/messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from "react-intl";
+export const messages = defineMessages({
+    networkError: {
+        id: "networkError",
+        defaultMessage: "Could not save changes",
+        description: "Displayed when a general server error occurs during save",
+    },
+    offlineError: {
+        id: "offlineError",
+        defaultMessage: "Currently offline. Check your internet connection.",
+        description: "Error message to be shown when the app is offline",
+    },
+});

package/dist/src/Form/components/FormMask/FormMask.js

@@ -0,0 +1,11 @@
+import React from "react";
+import { View } from "react-native";
+import { useIntl } from "react-intl";
+import { styles } from "./FormMask.style";
+import { ActivityIndicator } from "../../../ActivityIndicator";
+import { messages } from "../../messages";
+export function FormMask() {
+    const { formatMessage } = useIntl();
+    return (React.createElement(View, { style: styles.mask, accessibilityLabel: formatMessage(messages.loadingA11YLabel) },
+        React.createElement(ActivityIndicator, null)));
+}

package/dist/src/Form/components/FormMask/FormMask.style.js

@@ -0,0 +1,15 @@
+import { StyleSheet } from "react-native";
+import { tokens } from "../../../utils/design";
+export const styles = StyleSheet.create({
+    mask: {
+        zIndex: tokens["elevation-modal"],
+        width: "100%",
+        height: "100%",
+        position: "absolute",
+        top: 0,
+        left: 0,
+        backgroundColor: tokens["color-overlay--dimmed"],
+        padding: tokens["space-base"],
+        justifyContent: "center",
+    },
+});

package/dist/src/Form/components/FormMask/index.js

@@ -0,0 +1 @@
+export { FormMask } from "./FormMask";