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

package/dist/hooks/useLogin.js

@@ -1,296 +1,296 @@
-import * as React from 'react';
-import { authService, Sentry } from '@oneblink/apps';
-import useIsMounted from './useIsMounted';
-import useBooleanState from './useBooleanState';
-export default function useLogin({ username, password, newPassword, newPasswordConfirmed, code, }) {
-    const isMounted = useIsMounted();
-    // Validation
-    const usernameValidation = React.useMemo(() => {
-        return {
-            isInvalid: !username.trim(),
-        };
-    }, [username]);
-    const passwordValidation = React.useMemo(() => {
-        return {
-            isInvalid: !password.trim(),
-        };
-    }, [password]);
-    const codeValidation = React.useMemo(() => {
-        return {
-            isInvalid: !code.trim(),
-        };
-    }, [code]);
-    const newPasswordValidation = React.useMemo(() => {
-        const validation = {
-            hasLowercaseLetter: /[a-z]+/.test(newPassword),
-            hasUpperCaseLetter: /[A-Z]+/.test(newPassword),
-            hasNumber: /\d+/.test(newPassword),
-            hasSpecialCharacter: /[\^$*.[\]{}()?|\-"!@#%&/,><':;|_~`]+/.test(newPassword),
-            hasMinLength: newPassword.length >= 8,
-            isInvalid: true,
-        };
-        validation.isInvalid =
-            !validation.hasLowercaseLetter ||
-                !validation.hasUpperCaseLetter ||
-                !validation.hasNumber ||
-                !validation.hasSpecialCharacter ||
-                !validation.hasMinLength;
-        return validation;
-    }, [newPassword]);
-    const newPasswordConfirmedValidation = React.useMemo(() => {
-        return {
-            isInvalid: newPassword !== newPasswordConfirmed,
-        };
-    }, [newPassword, newPasswordConfirmed]);
-    // Login & Reset Password
-    const [{ isResettingTemporaryPassword, isLoggingIn, loginError, resetTemporaryPasswordCallback, }, setLoginState,] = React.useState({
-        isResettingTemporaryPassword: false,
-        isLoggingIn: false,
-        loginError: null,
-        resetTemporaryPasswordCallback: null,
-    });
-    const clearLoginError = React.useCallback(() => setLoginState((current) => ({
-        ...current,
-        loginError: null,
-    })), []);
-    const loginWithUsernamePassword = React.useCallback(async () => {
-        if (usernameValidation.isInvalid) {
-            setLoginState((current) => ({
-                ...current,
-                loginError: new Error('Please enter a valid email address'),
-            }));
-            return;
-        }
-        if (passwordValidation.isInvalid) {
-            setLoginState((current) => ({
-                ...current,
-                loginError: new Error('Please enter a valid password'),
-            }));
-            return;
-        }
-        setLoginState({
-            isResettingTemporaryPassword: false,
-            resetTemporaryPasswordCallback: null,
-            isLoggingIn: true,
-            loginError: null,
-        });
-        try {
-            const newResetPasswordCallback = await authService.loginUsernamePassword(username, password);
-            if (newResetPasswordCallback) {
-                if (isMounted.current) {
-                    setLoginState({
-                        isResettingTemporaryPassword: false,
-                        isLoggingIn: false,
-                        resetTemporaryPasswordCallback: newResetPasswordCallback,
-                        loginError: null,
-                    });
-                }
-            }
-        }
-        catch (error) {
-            Sentry.captureException(error);
-            if (isMounted.current) {
-                setLoginState({
-                    isResettingTemporaryPassword: false,
-                    isLoggingIn: false,
-                    resetTemporaryPasswordCallback: null,
-                    loginError: error,
-                });
-            }
-        }
-    }, [
-        isMounted,
-        password,
-        passwordValidation.isInvalid,
-        username,
-        usernameValidation.isInvalid,
-    ]);
-    const resetTemporaryPassword = React.useCallback(async () => {
-        if (!resetTemporaryPasswordCallback) {
-            return;
-        }
-        if (newPasswordValidation.isInvalid) {
-            setLoginState((current) => ({
-                ...current,
-                loginError: new Error('Please enter a valid password'),
-            }));
-            return;
-        }
-        if (newPasswordConfirmedValidation.isInvalid) {
-            setLoginState((current) => ({
-                ...current,
-                loginError: new Error('Please confirm your new password'),
-            }));
-            return;
-        }
-        setLoginState((current) => ({
-            ...current,
-            isResettingPassword: true,
-            loginError: null,
-        }));
-        try {
-            await resetTemporaryPasswordCallback(newPassword);
-        }
-        catch (error) {
-            Sentry.captureException(error);
-            if (isMounted.current) {
-                setLoginState((current) => ({
-                    ...current,
-                    isResettingPassword: false,
-                    loginError: error,
-                }));
-            }
-        }
-    }, [
-        isMounted,
-        newPassword,
-        newPasswordConfirmedValidation.isInvalid,
-        newPasswordValidation.isInvalid,
-        resetTemporaryPasswordCallback,
-    ]);
-    // Forgot Password
-    const [isShowingForgotPassword, showForgotPassword, hideForgotPassword] = useBooleanState(false);
-    const [{ resetForgottenPasswordCallback, isSendingForgotPasswordCode, isResettingForgottenPassword, forgotPasswordError, }, setForgotPasswordState,] = React.useState({
-        isSendingForgotPasswordCode: false,
-        forgotPasswordError: null,
-        resetForgottenPasswordCallback: null,
-        isResettingForgottenPassword: false,
-    });
-    const clearForgotPasswordError = React.useCallback(() => setForgotPasswordState((current) => ({
-        ...current,
-        forgotPasswordError: null,
-    })), []);
-    const sendForgotPasswordCode = React.useCallback(async () => {
-        if (usernameValidation.isInvalid) {
-            setForgotPasswordState((current) => ({
-                ...current,
-                forgotPasswordError: new Error('Please enter a valid email address'),
-            }));
-            return;
-        }
-        setForgotPasswordState({
-            isSendingForgotPasswordCode: true,
-            resetForgottenPasswordCallback: null,
-            forgotPasswordError: null,
-            isResettingForgottenPassword: false,
-        });
-        try {
-            const newResetForgottenPasswordCallback = await authService.forgotPassword(username);
-            if (isMounted.current) {
-                setForgotPasswordState({
-                    isSendingForgotPasswordCode: false,
-                    resetForgottenPasswordCallback: newResetForgottenPasswordCallback,
-                    forgotPasswordError: null,
-                    isResettingForgottenPassword: false,
-                });
-            }
-        }
-        catch (error) {
-            Sentry.captureException(error);
-            if (isMounted.current) {
-                setForgotPasswordState({
-                    isSendingForgotPasswordCode: false,
-                    resetForgottenPasswordCallback: null,
-                    forgotPasswordError: error,
-                    isResettingForgottenPassword: false,
-                });
-            }
-        }
-    }, [isMounted, username, usernameValidation.isInvalid]);
-    const resetForgottenPassword = React.useCallback(async () => {
-        if (!resetForgottenPasswordCallback) {
-            return;
-        }
-        if (codeValidation.isInvalid) {
-            setForgotPasswordState((current) => ({
-                ...current,
-                forgotPasswordError: new Error('Please enter the code that was sent to your email address'),
-            }));
-        }
-        if (newPasswordValidation.isInvalid) {
-            setForgotPasswordState((current) => ({
-                ...current,
-                forgotPasswordError: new Error('Please enter a valid password'),
-            }));
-            return;
-        }
-        if (newPasswordConfirmedValidation.isInvalid) {
-            setForgotPasswordState((current) => ({
-                ...current,
-                forgotPasswordError: new Error('Please confirm your new password'),
-            }));
-            return;
-        }
-        setForgotPasswordState((current) => ({
-            ...current,
-            isChangingPassword: true,
-            forgotPasswordError: null,
-        }));
-        try {
-            await resetForgottenPasswordCallback(code, newPassword);
-            if (isMounted.current) {
-                setForgotPasswordState({
-                    isSendingForgotPasswordCode: false,
-                    resetForgottenPasswordCallback: null,
-                    forgotPasswordError: null,
-                    isResettingForgottenPassword: false,
-                });
-                hideForgotPassword();
-            }
-        }
-        catch (error) {
-            Sentry.captureException(error);
-            if (isMounted.current) {
-                setForgotPasswordState((current) => ({
-                    ...current,
-                    isChangingPassword: false,
-                    forgotPasswordError: error,
-                }));
-            }
-        }
-    }, [
-        resetForgottenPasswordCallback,
-        codeValidation.isInvalid,
-        newPasswordValidation.isInvalid,
-        newPasswordConfirmedValidation.isInvalid,
-        code,
-        newPassword,
-        isMounted,
-        hideForgotPassword,
-    ]);
-    const loginWithGoogle = React.useCallback(() => {
-        authService.loginHostedUI('Google');
-    }, []);
-    return {
-        // Login
-        loginWithGoogle,
-        loginWithUsernamePassword,
-        isLoggingIn,
-        loginError,
-        clearLoginError,
-        // Reset Temp Password
-        isPasswordTemporary: !!resetTemporaryPasswordCallback,
-        isResettingTemporaryPassword,
-        resetTemporaryPassword,
-        // Showing Forgot Password
-        isShowingForgotPassword,
-        showForgotPassword,
-        hideForgotPassword,
-        forgotPasswordError,
-        clearForgotPasswordError,
-        // Sending Forgot Password Code
-        isSendingForgotPasswordCode,
-        sendForgotPasswordCode,
-        // Resetting Forgotten Password
-        hasSentForgotPasswordCode: !!resetForgottenPasswordCallback,
-        isResettingForgottenPassword,
-        resetForgottenPassword,
-        // Validation
-        usernameValidation,
-        passwordValidation,
-        codeValidation,
-        newPasswordValidation,
-        newPasswordConfirmedValidation,
-    };
-}
+import * as React from 'react';
+import { authService, Sentry } from '@oneblink/apps';
+import useIsMounted from './useIsMounted';
+import useBooleanState from './useBooleanState';
+export default function useLogin({ username, password, newPassword, newPasswordConfirmed, code, }) {
+    const isMounted = useIsMounted();
+    // Validation
+    const usernameValidation = React.useMemo(() => {
+        return {
+            isInvalid: !username.trim(),
+        };
+    }, [username]);
+    const passwordValidation = React.useMemo(() => {
+        return {
+            isInvalid: !password.trim(),
+        };
+    }, [password]);
+    const codeValidation = React.useMemo(() => {
+        return {
+            isInvalid: !code.trim(),
+        };
+    }, [code]);
+    const newPasswordValidation = React.useMemo(() => {
+        const validation = {
+            hasLowercaseLetter: /[a-z]+/.test(newPassword),
+            hasUpperCaseLetter: /[A-Z]+/.test(newPassword),
+            hasNumber: /\d+/.test(newPassword),
+            hasSpecialCharacter: /[\^$*.[\]{}()?|\-"!@#%&/,><':;|_~`]+/.test(newPassword),
+            hasMinLength: newPassword.length >= 8,
+            isInvalid: true,
+        };
+        validation.isInvalid =
+            !validation.hasLowercaseLetter ||
+                !validation.hasUpperCaseLetter ||
+                !validation.hasNumber ||
+                !validation.hasSpecialCharacter ||
+                !validation.hasMinLength;
+        return validation;
+    }, [newPassword]);
+    const newPasswordConfirmedValidation = React.useMemo(() => {
+        return {
+            isInvalid: newPassword !== newPasswordConfirmed,
+        };
+    }, [newPassword, newPasswordConfirmed]);
+    // Login & Reset Password
+    const [{ isResettingTemporaryPassword, isLoggingIn, loginError, resetTemporaryPasswordCallback, }, setLoginState,] = React.useState({
+        isResettingTemporaryPassword: false,
+        isLoggingIn: false,
+        loginError: null,
+        resetTemporaryPasswordCallback: null,
+    });
+    const clearLoginError = React.useCallback(() => setLoginState((current) => ({
+        ...current,
+        loginError: null,
+    })), []);
+    const loginWithUsernamePassword = React.useCallback(async () => {
+        if (usernameValidation.isInvalid) {
+            setLoginState((current) => ({
+                ...current,
+                loginError: new Error('Please enter a valid email address'),
+            }));
+            return;
+        }
+        if (passwordValidation.isInvalid) {
+            setLoginState((current) => ({
+                ...current,
+                loginError: new Error('Please enter a valid password'),
+            }));
+            return;
+        }
+        setLoginState({
+            isResettingTemporaryPassword: false,
+            resetTemporaryPasswordCallback: null,
+            isLoggingIn: true,
+            loginError: null,
+        });
+        try {
+            const newResetPasswordCallback = await authService.loginUsernamePassword(username, password);
+            if (newResetPasswordCallback) {
+                if (isMounted.current) {
+                    setLoginState({
+                        isResettingTemporaryPassword: false,
+                        isLoggingIn: false,
+                        resetTemporaryPasswordCallback: newResetPasswordCallback,
+                        loginError: null,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            Sentry.captureException(error);
+            if (isMounted.current) {
+                setLoginState({
+                    isResettingTemporaryPassword: false,
+                    isLoggingIn: false,
+                    resetTemporaryPasswordCallback: null,
+                    loginError: error,
+                });
+            }
+        }
+    }, [
+        isMounted,
+        password,
+        passwordValidation.isInvalid,
+        username,
+        usernameValidation.isInvalid,
+    ]);
+    const resetTemporaryPassword = React.useCallback(async () => {
+        if (!resetTemporaryPasswordCallback) {
+            return;
+        }
+        if (newPasswordValidation.isInvalid) {
+            setLoginState((current) => ({
+                ...current,
+                loginError: new Error('Please enter a valid password'),
+            }));
+            return;
+        }
+        if (newPasswordConfirmedValidation.isInvalid) {
+            setLoginState((current) => ({
+                ...current,
+                loginError: new Error('Please confirm your new password'),
+            }));
+            return;
+        }
+        setLoginState((current) => ({
+            ...current,
+            isResettingPassword: true,
+            loginError: null,
+        }));
+        try {
+            await resetTemporaryPasswordCallback(newPassword);
+        }
+        catch (error) {
+            Sentry.captureException(error);
+            if (isMounted.current) {
+                setLoginState((current) => ({
+                    ...current,
+                    isResettingPassword: false,
+                    loginError: error,
+                }));
+            }
+        }
+    }, [
+        isMounted,
+        newPassword,
+        newPasswordConfirmedValidation.isInvalid,
+        newPasswordValidation.isInvalid,
+        resetTemporaryPasswordCallback,
+    ]);
+    // Forgot Password
+    const [isShowingForgotPassword, showForgotPassword, hideForgotPassword] = useBooleanState(false);
+    const [{ resetForgottenPasswordCallback, isSendingForgotPasswordCode, isResettingForgottenPassword, forgotPasswordError, }, setForgotPasswordState,] = React.useState({
+        isSendingForgotPasswordCode: false,
+        forgotPasswordError: null,
+        resetForgottenPasswordCallback: null,
+        isResettingForgottenPassword: false,
+    });
+    const clearForgotPasswordError = React.useCallback(() => setForgotPasswordState((current) => ({
+        ...current,
+        forgotPasswordError: null,
+    })), []);
+    const sendForgotPasswordCode = React.useCallback(async () => {
+        if (usernameValidation.isInvalid) {
+            setForgotPasswordState((current) => ({
+                ...current,
+                forgotPasswordError: new Error('Please enter a valid email address'),
+            }));
+            return;
+        }
+        setForgotPasswordState({
+            isSendingForgotPasswordCode: true,
+            resetForgottenPasswordCallback: null,
+            forgotPasswordError: null,
+            isResettingForgottenPassword: false,
+        });
+        try {
+            const newResetForgottenPasswordCallback = await authService.forgotPassword(username);
+            if (isMounted.current) {
+                setForgotPasswordState({
+                    isSendingForgotPasswordCode: false,
+                    resetForgottenPasswordCallback: newResetForgottenPasswordCallback,
+                    forgotPasswordError: null,
+                    isResettingForgottenPassword: false,
+                });
+            }
+        }
+        catch (error) {
+            Sentry.captureException(error);
+            if (isMounted.current) {
+                setForgotPasswordState({
+                    isSendingForgotPasswordCode: false,
+                    resetForgottenPasswordCallback: null,
+                    forgotPasswordError: error,
+                    isResettingForgottenPassword: false,
+                });
+            }
+        }
+    }, [isMounted, username, usernameValidation.isInvalid]);
+    const resetForgottenPassword = React.useCallback(async () => {
+        if (!resetForgottenPasswordCallback) {
+            return;
+        }
+        if (codeValidation.isInvalid) {
+            setForgotPasswordState((current) => ({
+                ...current,
+                forgotPasswordError: new Error('Please enter the code that was sent to your email address'),
+            }));
+        }
+        if (newPasswordValidation.isInvalid) {
+            setForgotPasswordState((current) => ({
+                ...current,
+                forgotPasswordError: new Error('Please enter a valid password'),
+            }));
+            return;
+        }
+        if (newPasswordConfirmedValidation.isInvalid) {
+            setForgotPasswordState((current) => ({
+                ...current,
+                forgotPasswordError: new Error('Please confirm your new password'),
+            }));
+            return;
+        }
+        setForgotPasswordState((current) => ({
+            ...current,
+            isChangingPassword: true,
+            forgotPasswordError: null,
+        }));
+        try {
+            await resetForgottenPasswordCallback(code, newPassword);
+            if (isMounted.current) {
+                setForgotPasswordState({
+                    isSendingForgotPasswordCode: false,
+                    resetForgottenPasswordCallback: null,
+                    forgotPasswordError: null,
+                    isResettingForgottenPassword: false,
+                });
+                hideForgotPassword();
+            }
+        }
+        catch (error) {
+            Sentry.captureException(error);
+            if (isMounted.current) {
+                setForgotPasswordState((current) => ({
+                    ...current,
+                    isChangingPassword: false,
+                    forgotPasswordError: error,
+                }));
+            }
+        }
+    }, [
+        resetForgottenPasswordCallback,
+        codeValidation.isInvalid,
+        newPasswordValidation.isInvalid,
+        newPasswordConfirmedValidation.isInvalid,
+        code,
+        newPassword,
+        isMounted,
+        hideForgotPassword,
+    ]);
+    const loginWithGoogle = React.useCallback(() => {
+        authService.loginHostedUI('Google');
+    }, []);
+    return {
+        // Login
+        loginWithGoogle,
+        loginWithUsernamePassword,
+        isLoggingIn,
+        loginError,
+        clearLoginError,
+        // Reset Temp Password
+        isPasswordTemporary: !!resetTemporaryPasswordCallback,
+        isResettingTemporaryPassword,
+        resetTemporaryPassword,
+        // Showing Forgot Password
+        isShowingForgotPassword,
+        showForgotPassword,
+        hideForgotPassword,
+        forgotPasswordError,
+        clearForgotPasswordError,
+        // Sending Forgot Password Code
+        isSendingForgotPasswordCode,
+        sendForgotPasswordCode,
+        // Resetting Forgotten Password
+        hasSentForgotPasswordCode: !!resetForgottenPasswordCallback,
+        isResettingForgottenPassword,
+        resetForgottenPassword,
+        // Validation
+        usernameValidation,
+        passwordValidation,
+        codeValidation,
+        newPasswordValidation,
+        newPasswordConfirmedValidation,
+    };
+}
 //# sourceMappingURL=useLogin.js.map

package/dist/hooks/useLookupNotification.d.ts

@@ -1,9 +1,9 @@
-import * as React from 'react';
-declare type LookupNotificationContextValue = {
-    isLookup: boolean;
-    isDisabled: boolean;
-    onLookup: (value: unknown) => Promise<void>;
-};
-export declare const LookupNotificationContext: React.Context<LookupNotificationContextValue>;
-export default function useLookupNotification(): LookupNotificationContextValue;
-export {};
+import * as React from 'react';
+declare type LookupNotificationContextValue = {
+    isLookup: boolean;
+    isDisabled: boolean;
+    onLookup: (value: unknown) => Promise<void>;
+};
+export declare const LookupNotificationContext: React.Context<LookupNotificationContextValue>;
+export default function useLookupNotification(): LookupNotificationContextValue;
+export {};

package/dist/hooks/useLookupNotification.js

@@ -1,11 +1,11 @@
-import * as React from 'react';
-const defaultContext = {
-    isLookup: false,
-    isDisabled: false,
-    onLookup: async () => { },
-};
-export const LookupNotificationContext = React.createContext(defaultContext);
-export default function useLookupNotification() {
-    return React.useContext(LookupNotificationContext);
-}
+import * as React from 'react';
+const defaultContext = {
+    isLookup: false,
+    isDisabled: false,
+    onLookup: async () => { },
+};
+export const LookupNotificationContext = React.createContext(defaultContext);
+export default function useLookupNotification() {
+    return React.useContext(LookupNotificationContext);
+}
 //# sourceMappingURL=useLookupNotification.js.map

package/dist/hooks/useLookups.d.ts

@@ -1,5 +1,5 @@
-import { FormTypes } from '@oneblink/types';
-import { FormSubmissionModel, SetFormSubmission } from '../types/form';
-export default function useLookups(formId: number, setFormSubmission: SetFormSubmission): {
-    handlePagesLookupResult: (element: FormTypes.LookupFormElement, elementLookupData: FormTypes.PageElement[], dataLookupResult?: FormSubmissionModel) => void;
-};
+import { FormTypes } from '@oneblink/types';
+import { FormSubmissionModel, SetFormSubmission } from '../types/form';
+export default function useLookups(formId: number, setFormSubmission: SetFormSubmission): {
+    handlePagesLookupResult: (element: FormTypes.LookupFormElement, elementLookupData: FormTypes.PageElement[], dataLookupResult?: FormSubmissionModel) => void;
+};