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

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/useLoadDataState.d.ts

@@ -1,15 +1,15 @@
-import * as React from 'react';
-export declare type LoadDataState<T> = {
-    status: 'SUCCESS';
-    result: T;
-} | {
-    status: 'ERROR';
-    error: Error;
-} | {
-    status: 'LOADING';
-};
-export default function useLoadDataState<T>(onLoad: (abortSignal?: AbortSignal) => Promise<T>): [
-    LoadDataState<T>,
-    (abortSignal?: AbortSignal) => void,
-    React.Dispatch<React.SetStateAction<T>>
-];
+import * as React from 'react';
+export declare type LoadDataState<T> = {
+    status: 'SUCCESS';
+    result: T;
+} | {
+    status: 'ERROR';
+    error: Error;
+} | {
+    status: 'LOADING';
+};
+export default function useLoadDataState<T>(onLoad: (abortSignal?: AbortSignal) => Promise<T>): [
+    LoadDataState<T>,
+    (abortSignal?: AbortSignal) => void,
+    React.Dispatch<React.SetStateAction<T>>
+];

package/dist/hooks/useLoadDataState.js

@@ -1,55 +1,55 @@
-import * as React from 'react';
-import useIsMounted from './useIsMounted';
-export default function useLoadDataState(onLoad) {
-    const isMounted = useIsMounted();
-    const [state, setState] = React.useState({
-        status: 'LOADING',
-    });
-    const handleLoad = React.useCallback(async (abortSignal) => {
-        setState({
-            status: 'LOADING',
-        });
-        try {
-            const result = await onLoad(abortSignal);
-            if (isMounted.current && !(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
-                setState({
-                    status: 'SUCCESS',
-                    result,
-                });
-            }
-        }
-        catch (err) {
-            if (isMounted.current && !(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
-                setState({
-                    status: 'ERROR',
-                    error: err,
-                });
-            }
-        }
-    }, [isMounted, onLoad]);
-    const setResult = React.useCallback((setter) => {
-        setState((currentState) => {
-            if (currentState.status === 'SUCCESS') {
-                return {
-                    ...currentState,
-                    result: typeof setter === 'function'
-                        ? // @ts-expect-error Typescript cannot tell between a generic type (T) and a function
-                            setter(currentState.result)
-                        : setter,
-                };
-            }
-            else {
-                return currentState;
-            }
-        });
-    }, []);
-    React.useEffect(() => {
-        const abortController = new AbortController();
-        handleLoad(abortController.signal);
-        return () => {
-            abortController.abort();
-        };
-    }, [handleLoad]);
-    return [state, handleLoad, setResult];
-}
+import * as React from 'react';
+import useIsMounted from './useIsMounted';
+export default function useLoadDataState(onLoad) {
+    const isMounted = useIsMounted();
+    const [state, setState] = React.useState({
+        status: 'LOADING',
+    });
+    const handleLoad = React.useCallback(async (abortSignal) => {
+        setState({
+            status: 'LOADING',
+        });
+        try {
+            const result = await onLoad(abortSignal);
+            if (isMounted.current && !(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
+                setState({
+                    status: 'SUCCESS',
+                    result,
+                });
+            }
+        }
+        catch (err) {
+            if (isMounted.current && !(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
+                setState({
+                    status: 'ERROR',
+                    error: err,
+                });
+            }
+        }
+    }, [isMounted, onLoad]);
+    const setResult = React.useCallback((setter) => {
+        setState((currentState) => {
+            if (currentState.status === 'SUCCESS') {
+                return {
+                    ...currentState,
+                    result: typeof setter === 'function'
+                        ? // @ts-expect-error Typescript cannot tell between a generic type (T) and a function
+                            setter(currentState.result)
+                        : setter,
+                };
+            }
+            else {
+                return currentState;
+            }
+        });
+    }, []);
+    React.useEffect(() => {
+        const abortController = new AbortController();
+        handleLoad(abortController.signal);
+        return () => {
+            abortController.abort();
+        };
+    }, [handleLoad]);
+    return [state, handleLoad, setResult];
+}
 //# sourceMappingURL=useLoadDataState.js.map