@oneblink/apps-react 2.2.0 → 2.3.0-beta.2

package/dist/hooks/useFormValidation.js

@@ -1,30 +1,30 @@
-import * as React from 'react';
-import { validateSubmission, generateValidationSchema, } from '../services/form-validation';
-export default function useFormValidation(pages) {
-    const [elementIdsWithLookupsExecuted, setElementIdsWithLookupsExecuted] = React.useState([]);
-    const executedLookup = React.useCallback((element) => {
-        setElementIdsWithLookupsExecuted((currentElementIdsWithLookupsExecuted) => {
-            if (currentElementIdsWithLookupsExecuted.includes(element.id)) {
-                return currentElementIdsWithLookupsExecuted;
-            }
-            return [...currentElementIdsWithLookupsExecuted, element.id];
-        });
-    }, []);
-    const executeLookupFailed = React.useCallback((element) => {
-        setElementIdsWithLookupsExecuted((currentElementIdsWithLookupsExecuted) => {
-            return currentElementIdsWithLookupsExecuted.filter((elementId) => elementId !== element.id);
-        });
-    }, []);
-    const validationSchema = React.useMemo(() => {
-        return generateValidationSchema(pages, elementIdsWithLookupsExecuted);
-    }, [pages, elementIdsWithLookupsExecuted]);
-    const handleValidate = React.useCallback((submission, formElementsConditionallyShown) => {
-        return validateSubmission(validationSchema, submission, formElementsConditionallyShown);
-    }, [validationSchema]);
-    return {
-        executedLookup,
-        executeLookupFailed,
-        validate: handleValidate,
-    };
-}
+import * as React from 'react';
+import { validateSubmission, generateValidationSchema, } from '../services/form-validation';
+export default function useFormValidation(pages) {
+    const [elementIdsWithLookupsExecuted, setElementIdsWithLookupsExecuted] = React.useState([]);
+    const executedLookup = React.useCallback((element) => {
+        setElementIdsWithLookupsExecuted((currentElementIdsWithLookupsExecuted) => {
+            if (currentElementIdsWithLookupsExecuted.includes(element.id)) {
+                return currentElementIdsWithLookupsExecuted;
+            }
+            return [...currentElementIdsWithLookupsExecuted, element.id];
+        });
+    }, []);
+    const executeLookupFailed = React.useCallback((element) => {
+        setElementIdsWithLookupsExecuted((currentElementIdsWithLookupsExecuted) => {
+            return currentElementIdsWithLookupsExecuted.filter((elementId) => elementId !== element.id);
+        });
+    }, []);
+    const validationSchema = React.useMemo(() => {
+        return generateValidationSchema(pages, elementIdsWithLookupsExecuted);
+    }, [pages, elementIdsWithLookupsExecuted]);
+    const handleValidate = React.useCallback((submission, formElementsConditionallyShown) => {
+        return validateSubmission(validationSchema, submission, formElementsConditionallyShown);
+    }, [validationSchema]);
+    return {
+        executedLookup,
+        executeLookupFailed,
+        validate: handleValidate,
+    };
+}
 //# sourceMappingURL=useFormValidation.js.map

package/dist/hooks/useGoogleMapsApiKey.d.ts

@@ -1,3 +1,3 @@
-import * as React from 'react';
-export declare const GoogleMapsApiKeyContext: React.Context<string | undefined>;
-export default function useGoogleMapsApiKeyKey(): string | undefined;
+import * as React from 'react';
+export declare const GoogleMapsApiKeyContext: React.Context<string | undefined>;
+export default function useGoogleMapsApiKeyKey(): string | undefined;

package/dist/hooks/useGoogleMapsApiKey.js

@@ -1,6 +1,6 @@
-import * as React from 'react';
-export const GoogleMapsApiKeyContext = React.createContext(undefined);
-export default function useGoogleMapsApiKeyKey() {
-    return React.useContext(GoogleMapsApiKeyContext);
-}
+import * as React from 'react';
+export const GoogleMapsApiKeyContext = React.createContext(undefined);
+export default function useGoogleMapsApiKeyKey() {
+    return React.useContext(GoogleMapsApiKeyContext);
+}
 //# sourceMappingURL=useGoogleMapsApiKey.js.map

package/dist/hooks/useInfiniteScrollDataLoad.d.ts

@@ -1,30 +1,30 @@
-import useQuery from './useQuery';
-export declare type ChangeHandler<T> = (filters: T) => T;
-export declare type OnChangeFilters<T> = (changeHandler: ChangeHandler<T>, shouldDebounce: boolean) => void;
-export declare type LoadingType = 'INITIAL' | 'MORE' | null;
-export default function useInfiniteScrollDataLoad<Filters, T>({ limit, debounceSearchMs, onDefaultFilters, onSearch, onValidateFilters, }: {
-    limit: number;
-    debounceSearchMs?: number;
-    onDefaultFilters: (query: ReturnType<typeof useQuery>) => Filters;
-    onSearch: (filters: Filters, paging: {
-        limit: number;
-        offset: number;
-    }, abortSignal: AbortSignal) => Promise<{
-        records: T[];
-        meta: {
-            limit: number;
-            offset: number;
-            nextOffset?: number | undefined;
-        };
-    }>;
-    onValidateFilters?: (filters: Filters) => boolean;
-}): {
-    isLoading: LoadingType;
-    loadError: Error | null;
-    records: T[];
-    onRefresh: () => void;
-    onTryAgain: (newOffset?: number) => void;
-    filters: Filters;
-    onChangeFilters: OnChangeFilters<Filters>;
-    onReplace: (replacer: (record: T) => T) => void;
-};
+import useQuery from './useQuery';
+export declare type ChangeHandler<T> = (filters: T) => T;
+export declare type OnChangeFilters<T> = (changeHandler: ChangeHandler<T>, shouldDebounce: boolean) => void;
+export declare type LoadingType = 'INITIAL' | 'MORE' | null;
+export default function useInfiniteScrollDataLoad<Filters, T>({ limit, debounceSearchMs, onDefaultFilters, onSearch, onValidateFilters, }: {
+    limit: number;
+    debounceSearchMs?: number;
+    onDefaultFilters: (query: ReturnType<typeof useQuery>) => Filters;
+    onSearch: (filters: Filters, paging: {
+        limit: number;
+        offset: number;
+    }, abortSignal: AbortSignal) => Promise<{
+        records: T[];
+        meta: {
+            limit: number;
+            offset: number;
+            nextOffset?: number | undefined;
+        };
+    }>;
+    onValidateFilters?: (filters: Filters) => boolean;
+}): {
+    isLoading: LoadingType;
+    loadError: Error | null;
+    records: T[];
+    onRefresh: () => void;
+    onTryAgain: (newOffset?: number) => void;
+    filters: Filters;
+    onChangeFilters: OnChangeFilters<Filters>;
+    onReplace: (replacer: (record: T) => T) => void;
+};

package/dist/hooks/useInfiniteScrollDataLoad.js

@@ -1,125 +1,125 @@
-import * as React from 'react';
-import useQuery from './useQuery';
-export default function useInfiniteScrollDataLoad({ limit, debounceSearchMs, onDefaultFilters, onSearch, onValidateFilters, }) {
-    const query = useQuery();
-    const [{ forceReload, shouldDebounce, offset, filters }, setOffsetState] = React.useState(() => {
-        return {
-            forceReload: false,
-            shouldDebounce: true,
-            offset: 0,
-            filters: onDefaultFilters(query),
-        };
-    });
-    const onChangeFilters = React.useCallback((changeHandler, shouldDebounce) => {
-        setOffsetState((currentState) => ({
-            ...currentState,
-            afterRefresh: false,
-            shouldDebounce,
-            offset: 0,
-            filters: changeHandler(currentState.filters),
-        }));
-    }, []);
-    const [{ isLoading, records, error, nextOffset }, setState] = React.useState({
-        isLoading: 'INITIAL',
-        records: [],
-        error: null,
-        nextOffset: 0,
-    });
-    const fetchRecords = React.useCallback(async (abortSignal) => {
-        if (onValidateFilters) {
-            const isValid = onValidateFilters(filters);
-            if (!isValid) {
-                return;
-            }
-        }
-        setState((currentState) => ({
-            ...currentState,
-            error: null,
-            records: offset === 0 ? [] : currentState.records,
-            isLoading: offset === 0 ? 'INITIAL' : 'MORE',
-        }));
-        try {
-            const result = await onSearch(filters, {
-                limit,
-                offset,
-            }, abortSignal);
-            setState((currentState) => ({
-                error: null,
-                records: [...currentState.records, ...result.records],
-                isLoading: null,
-                nextOffset: result.meta.nextOffset || 0,
-            }));
-        }
-        catch (error) {
-            if (abortSignal.aborted) {
-                return;
-            }
-            console.warn('An error occurred while fetching records', error);
-            setState((currentState) => ({
-                ...currentState,
-                error: error,
-                isLoading: null,
-            }));
-        }
-    }, [onValidateFilters, filters, offset, onSearch, limit]);
-    React.useEffect(() => {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => {
-            fetchRecords(controller.signal);
-        }, shouldDebounce ? debounceSearchMs || 0 : 0);
-        return () => {
-            clearTimeout(timeoutId);
-            controller.abort();
-        };
-    }, [debounceSearchMs, fetchRecords, shouldDebounce, forceReload]);
-    const onLoad = React.useCallback((newOffset) => {
-        setOffsetState((currentState) => {
-            return {
-                ...currentState,
-                offset: typeof newOffset === 'number' ? newOffset : currentState.offset,
-                forceReload: !currentState.forceReload,
-                shouldDebounce: false,
-            };
-        });
-    }, []);
-    React.useEffect(() => {
-        const scrollEventListener = () => {
-            // Bails early if we have not fetched data yet and:
-            // - there's an error
-            // - it's already loading
-            // - there's nothing left to load
-            if (!document.body || error || isLoading || !nextOffset) {
-                return;
-            }
-            // Checks that the page has scrolled to the bottom
-            if (window.innerHeight + window.scrollY >= document.body.scrollHeight) {
-                onLoad(nextOffset);
-            }
-        };
-        // Binds our scroll event handler
-        window.addEventListener('scroll', scrollEventListener);
-        return () => {
-            window.removeEventListener('scroll', scrollEventListener);
-        };
-    }, [error, isLoading, nextOffset, onLoad]);
-    const onRefresh = React.useCallback(() => {
-        onLoad(0);
-    }, [onLoad]);
-    const onReplace = React.useCallback((replacer) => {
-        setState((state) => ({
-            ...state,
-            records: state.records.map(replacer),
-        }));
-    }, []);
-    return {
-        isLoading,
-        loadError: error,
-        records,
-        onRefresh,
-        onTryAgain: onLoad,
-        filters,
-        onChangeFilters,
-        onReplace,
-    };
-}
+import * as React from 'react';
+import useQuery from './useQuery';
+export default function useInfiniteScrollDataLoad({ limit, debounceSearchMs, onDefaultFilters, onSearch, onValidateFilters, }) {
+    const query = useQuery();
+    const [{ forceReload, shouldDebounce, offset, filters }, setOffsetState] = React.useState(() => {
+        return {
+            forceReload: false,
+            shouldDebounce: true,
+            offset: 0,
+            filters: onDefaultFilters(query),
+        };
+    });
+    const onChangeFilters = React.useCallback((changeHandler, shouldDebounce) => {
+        setOffsetState((currentState) => ({
+            ...currentState,
+            afterRefresh: false,
+            shouldDebounce,
+            offset: 0,
+            filters: changeHandler(currentState.filters),
+        }));
+    }, []);
+    const [{ isLoading, records, error, nextOffset }, setState] = React.useState({
+        isLoading: 'INITIAL',
+        records: [],
+        error: null,
+        nextOffset: 0,
+    });
+    const fetchRecords = React.useCallback(async (abortSignal) => {
+        if (onValidateFilters) {
+            const isValid = onValidateFilters(filters);
+            if (!isValid) {
+                return;
+            }
+        }
+        setState((currentState) => ({
+            ...currentState,
+            error: null,
+            records: offset === 0 ? [] : currentState.records,
+            isLoading: offset === 0 ? 'INITIAL' : 'MORE',
+        }));
+        try {
+            const result = await onSearch(filters, {
+                limit,
+                offset,
+            }, abortSignal);
+            setState((currentState) => ({
+                error: null,
+                records: [...currentState.records, ...result.records],
+                isLoading: null,
+                nextOffset: result.meta.nextOffset || 0,
+            }));
+        }
+        catch (error) {
+            if (abortSignal.aborted) {
+                return;
+            }
+            console.warn('An error occurred while fetching records', error);
+            setState((currentState) => ({
+                ...currentState,
+                error: error,
+                isLoading: null,
+            }));
+        }
+    }, [onValidateFilters, filters, offset, onSearch, limit]);
+    React.useEffect(() => {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            fetchRecords(controller.signal);
+        }, shouldDebounce ? debounceSearchMs || 0 : 0);
+        return () => {
+            clearTimeout(timeoutId);
+            controller.abort();
+        };
+    }, [debounceSearchMs, fetchRecords, shouldDebounce, forceReload]);
+    const onLoad = React.useCallback((newOffset) => {
+        setOffsetState((currentState) => {
+            return {
+                ...currentState,
+                offset: typeof newOffset === 'number' ? newOffset : currentState.offset,
+                forceReload: !currentState.forceReload,
+                shouldDebounce: false,
+            };
+        });
+    }, []);
+    React.useEffect(() => {
+        const scrollEventListener = () => {
+            // Bails early if we have not fetched data yet and:
+            // - there's an error
+            // - it's already loading
+            // - there's nothing left to load
+            if (!document.body || error || isLoading || !nextOffset) {
+                return;
+            }
+            // Checks that the page has scrolled to the bottom
+            if (window.innerHeight + window.scrollY >= document.body.scrollHeight) {
+                onLoad(nextOffset);
+            }
+        };
+        // Binds our scroll event handler
+        window.addEventListener('scroll', scrollEventListener);
+        return () => {
+            window.removeEventListener('scroll', scrollEventListener);
+        };
+    }, [error, isLoading, nextOffset, onLoad]);
+    const onRefresh = React.useCallback(() => {
+        onLoad(0);
+    }, [onLoad]);
+    const onReplace = React.useCallback((replacer) => {
+        setState((state) => ({
+            ...state,
+            records: state.records.map(replacer),
+        }));
+    }, []);
+    return {
+        isLoading,
+        loadError: error,
+        records,
+        onRefresh,
+        onTryAgain: onLoad,
+        filters,
+        onChangeFilters,
+        onReplace,
+    };
+}
 //# sourceMappingURL=useInfiniteScrollDataLoad.js.map

package/dist/hooks/useInjectPages.d.ts

@@ -1,7 +1,7 @@
-import { FormTypes } from '@oneblink/types';
-import * as React from 'react';
-import { FormSubmissionModel } from '../types/form';
-declare type InjectPagesContextValue = (lookupFormElement: FormTypes.LookupFormElement, pageElements: FormTypes.PageElement[], data?: FormSubmissionModel) => void;
-export declare const InjectPagesContext: React.Context<InjectPagesContextValue>;
-export default function useInjectPages(): InjectPagesContextValue;
-export {};
+import { FormTypes } from '@oneblink/types';
+import * as React from 'react';
+import { FormSubmissionModel } from '../types/form';
+declare type InjectPagesContextValue = (lookupFormElement: FormTypes.LookupFormElement, pageElements: FormTypes.PageElement[], data?: FormSubmissionModel) => void;
+export declare const InjectPagesContext: React.Context<InjectPagesContextValue>;
+export default function useInjectPages(): InjectPagesContextValue;
+export {};

package/dist/hooks/useInjectPages.js

@@ -1,6 +1,6 @@
-import * as React from 'react';
-export const InjectPagesContext = React.createContext(() => { });
-export default function useInjectPages() {
-    return React.useContext(InjectPagesContext);
-}
+import * as React from 'react';
+export const InjectPagesContext = React.createContext(() => { });
+export default function useInjectPages() {
+    return React.useContext(InjectPagesContext);
+}
 //# sourceMappingURL=useInjectPages.js.map

package/dist/hooks/useIsHovering.d.ts

@@ -1,5 +1,5 @@
-import * as React from 'react';
-declare const IsHoveringContext: React.Context<boolean>;
-export declare const IsHoveringProvider: React.ForwardRefExoticComponent<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & React.RefAttributes<HTMLDivElement>>;
-export declare function useIsHovering(): boolean;
-export default IsHoveringContext;
+import * as React from 'react';
+declare const IsHoveringContext: React.Context<boolean>;
+export declare const IsHoveringProvider: React.ForwardRefExoticComponent<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & React.RefAttributes<HTMLDivElement>>;
+export declare function useIsHovering(): boolean;
+export default IsHoveringContext;

package/dist/hooks/useIsHovering.js

@@ -1,13 +1,13 @@
-import * as React from 'react';
-import useBooleanState from './useBooleanState';
-const IsHoveringContext = React.createContext(false);
-export const IsHoveringProvider = React.forwardRef(function IsHoveringProvider(props, ref) {
-    const [isHovering, startHovering, stopHovering] = useBooleanState(false);
-    return (React.createElement(IsHoveringContext.Provider, { value: isHovering },
-        React.createElement("div", { ...props, onMouseEnter: startHovering, onMouseLeave: stopHovering, ref: ref })));
-});
-export function useIsHovering() {
-    return React.useContext(IsHoveringContext);
-}
-export default IsHoveringContext;
+import * as React from 'react';
+import useBooleanState from './useBooleanState';
+const IsHoveringContext = React.createContext(false);
+export const IsHoveringProvider = React.forwardRef(function IsHoveringProvider(props, ref) {
+    const [isHovering, startHovering, stopHovering] = useBooleanState(false);
+    return (React.createElement(IsHoveringContext.Provider, { value: isHovering },
+        React.createElement("div", { ...props, onMouseEnter: startHovering, onMouseLeave: stopHovering, ref: ref })));
+});
+export function useIsHovering() {
+    return React.useContext(IsHoveringContext);
+}
+export default IsHoveringContext;
 //# sourceMappingURL=useIsHovering.js.map

package/dist/hooks/useIsMounted.d.ts

@@ -1,3 +1,3 @@
-export default function useIsMounted(): {
-    current: boolean;
-};
+export default function useIsMounted(): {
+    current: boolean;
+};

package/dist/hooks/useIsMounted.js

@@ -1,12 +1,12 @@
-import * as React from 'react';
-export default function useIsMounted() {
-    const isMounted = React.useRef(false);
-    React.useEffect(() => {
-        isMounted.current = true;
-        return () => {
-            isMounted.current = false;
-        };
-    }, []);
-    return isMounted;
-}
+import * as React from 'react';
+export default function useIsMounted() {
+    const isMounted = React.useRef(false);
+    React.useEffect(() => {
+        isMounted.current = true;
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    return isMounted;
+}
 //# sourceMappingURL=useIsMounted.js.map

package/dist/hooks/useIsOffline.d.ts

@@ -1,6 +1,6 @@
-import * as React from 'react';
-export declare const useNetworkChangeEffect: (type: 'online' | 'offline', listener: () => unknown) => void;
-export declare function IsOfflineContextProvider({ children, }: {
-    children: React.ReactNode;
-}): JSX.Element;
-export default function useIsOffline(): boolean;
+import * as React from 'react';
+export declare const useNetworkChangeEffect: (type: 'online' | 'offline', listener: () => unknown) => void;
+export declare function IsOfflineContextProvider({ children, }: {
+    children: React.ReactNode;
+}): JSX.Element;
+export default function useIsOffline(): boolean;

package/dist/hooks/useIsOffline.js

@@ -1,27 +1,27 @@
-import * as React from 'react';
-import { offlineService } from '@oneblink/apps';
-import useBooleanState from '../hooks/useBooleanState';
-const defaultValue = offlineService.isOffline();
-const IsOfflineContext = React.createContext(defaultValue);
-export const useNetworkChangeEffect = (type, listener) => {
-    React.useEffect(() => {
-        // Stupid cordova seems to require that offline/online
-        // listeners are set on the document and browsers seem
-        // to require window.
-        const element = window.cordova ? document : window;
-        element.addEventListener(type, listener);
-        return () => {
-            element.removeEventListener(type, listener);
-        };
-    }, [type, listener]);
-};
-export function IsOfflineContextProvider({ children, }) {
-    const [isOffline, goOffline, goOnline] = useBooleanState(defaultValue);
-    useNetworkChangeEffect('online', goOnline);
-    useNetworkChangeEffect('offline', goOffline);
-    return (React.createElement(IsOfflineContext.Provider, { value: isOffline }, children));
-}
-export default function useIsOffline() {
-    return React.useContext(IsOfflineContext);
-}
+import * as React from 'react';
+import { offlineService } from '@oneblink/apps';
+import useBooleanState from '../hooks/useBooleanState';
+const defaultValue = offlineService.isOffline();
+const IsOfflineContext = React.createContext(defaultValue);
+export const useNetworkChangeEffect = (type, listener) => {
+    React.useEffect(() => {
+        // Stupid cordova seems to require that offline/online
+        // listeners are set on the document and browsers seem
+        // to require window.
+        const element = window.cordova ? document : window;
+        element.addEventListener(type, listener);
+        return () => {
+            element.removeEventListener(type, listener);
+        };
+    }, [type, listener]);
+};
+export function IsOfflineContextProvider({ children, }) {
+    const [isOffline, goOffline, goOnline] = useBooleanState(defaultValue);
+    useNetworkChangeEffect('online', goOnline);
+    useNetworkChangeEffect('offline', goOffline);
+    return (React.createElement(IsOfflineContext.Provider, { value: isOffline }, children));
+}
+export default function useIsOffline() {
+    return React.useContext(IsOfflineContext);
+}
 //# sourceMappingURL=useIsOffline.js.map

package/dist/hooks/useIsPageVisible.d.ts

@@ -1,9 +1,9 @@
-import * as React from 'react';
-declare type IsPageVisibleContextValue = boolean;
-declare type Props = {
-    isPageVisible: IsPageVisibleContextValue;
-    children: React.ReactNode;
-};
-export declare function IsPageVisibleProvider({ isPageVisible, children }: Props): JSX.Element;
-export default function useIsPageVisible(): boolean;
-export {};
+import * as React from 'react';
+declare type IsPageVisibleContextValue = boolean;
+declare type Props = {
+    isPageVisible: IsPageVisibleContextValue;
+    children: React.ReactNode;
+};
+export declare function IsPageVisibleProvider({ isPageVisible, children }: Props): JSX.Element;
+export default function useIsPageVisible(): boolean;
+export {};

package/dist/hooks/useIsPageVisible.js

@@ -1,9 +1,9 @@
-import * as React from 'react';
-const IsPageVisibleContext = React.createContext(false);
-export function IsPageVisibleProvider({ isPageVisible, children }) {
-    return (React.createElement(IsPageVisibleContext.Provider, { value: isPageVisible }, children));
-}
-export default function useIsPageVisible() {
-    return React.useContext(IsPageVisibleContext);
-}
+import * as React from 'react';
+const IsPageVisibleContext = React.createContext(false);
+export function IsPageVisibleProvider({ isPageVisible, children }) {
+    return (React.createElement(IsPageVisibleContext.Provider, { value: isPageVisible }, children));
+}
+export default function useIsPageVisible() {
+    return React.useContext(IsPageVisibleContext);
+}
 //# sourceMappingURL=useIsPageVisible.js.map

package/dist/hooks/useLegacyElements.d.ts

@@ -0,0 +1,16 @@
+import { FormTypes } from '@oneblink/types';
+export declare const legacyNameRegex: RegExp;
+declare const useLegacyFormElements: (formElements: FormTypes.FormElement[]) => {
+    formElementsUsingLegacyStorage: {
+        name: string;
+        label: string;
+        id: string;
+    }[];
+    formElementsUsingLegacyNames: {
+        name: string;
+        label: string;
+        id: string;
+    }[];
+};
+export default useLegacyFormElements;
+export declare const useFormElementLegacyConfigMessage: (formElement: FormTypes.FormElement) => string | undefined;