@intra-mart/smartlime 1.3.0 → 1.4.0

package/lib/packages/OAuth/index.js

@@ -1,4 +1,4 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as SecureStore from 'expo-secure-store';
 import { exchangeCodeAsync, loadAsync, Prompt, refreshAsync, } from 'expo-auth-session';
 import { useCallback, useLayoutEffect, useMemo, useRef, } from 'react';
 import { Context as DefaultContext } from './Context';
@@ -70,13 +70,13 @@ const saveTokenStorage = async (storageKey, baseUrl, accessToken, refreshToken,
         refreshToken,
         expirationDate,
     };
-    return await AsyncStorage.setItem(storageKey, JSON.stringify(item));
+    return await SecureStore.setItemAsync(storageKey, JSON.stringify(item));
 };
 const deleteTokenStorage = async (tokenStorageKey) => {
-    return await AsyncStorage.removeItem(tokenStorageKey);
+    return await SecureStore.deleteItemAsync(tokenStorageKey);
 };
 const getTokenStorage = async (storageKey) => {
-    const state = await AsyncStorage.getItem(storageKey);
+    const state = await SecureStore.getItem(storageKey);
     if (state == null)
         return;
     const result = JSON.parse(state);

package/lib/packages/Smartlime/index.d.ts

@@ -3,6 +3,7 @@ import { IMMe } from '../Me';
 import { IMOAuth } from '../OAuth';
 import { IMSession } from '../Session';
 import { IMSearch } from '../Search';
+import { IMTenant } from '../Tenant';
 interface SmartlimeProps {
     children: JSX.Element;
     baseUrl: string;
@@ -10,10 +11,11 @@ interface SmartlimeProps {
      * prop is currently not working.
      */
     tenantId?: string;
+    imtenant: Omit<React.ComponentProps<typeof IMTenant>, 'children' | 'baseUrl' | 'tenantId'>;
     imoauth: Omit<React.ComponentProps<typeof IMOAuth>, 'children'>;
     imme?: Omit<React.ComponentProps<typeof IMMe>, 'children'>;
     imsession?: Omit<React.ComponentProps<typeof IMSession>, 'children'>;
     imseach?: Omit<React.ComponentProps<typeof IMSearch>, 'children'>;
 }
-export declare const Smartlime: ({ children, baseUrl, tenantId, imoauth, imme, imsession, imseach, }: SmartlimeProps) => import("react").JSX.Element;
+export declare const Smartlime: ({ children, baseUrl, tenantId, imtenant, imoauth, imme, imsession, imseach, }: SmartlimeProps) => import("react").JSX.Element;
 export {};

package/lib/packages/Smartlime/index.js

@@ -4,8 +4,8 @@ import { IMSession } from '../Session';
 import { IMSearch } from '../Search';
 import { IMTenant } from '../Tenant';
 import { NotSearchPropError } from './NotSearchPropError';
-export const Smartlime = ({ children, baseUrl, tenantId, imoauth, imme, imsession, imseach, }) => {
-    const imtenantProps = { baseUrl, tenantId };
+export const Smartlime = ({ children, baseUrl, tenantId, imtenant, imoauth, imme, imsession, imseach, }) => {
+    const imtenantProps = { baseUrl, tenantId, ...imtenant };
     const imseachProps = imseach != null
         ? imseach
         : {

package/lib/packages/Tenant/Context.d.ts

@@ -1,6 +1,13 @@
 /// <reference types="react" />
+import { FetchModuleState, Moudles } from '.';
+import { RenderTarget } from '../../_shared/renderTarget';
 export interface TenantContext {
     getBaseUrl: () => string;
     getTenantId: () => string | undefined;
+    getFetchModuleState: () => FetchModuleState;
+    getModuleInfo: () => Moudles | undefined;
+    destroyModuleInfo: () => Promise<void>;
+    fetchModuleInfo: () => Promise<void>;
+    modulesStateRenderTarget: RenderTarget;
 }
 export declare const Context: import("react").Context<TenantContext | null>;

package/lib/packages/Tenant/hooks/index.d.ts

@@ -1 +1,3 @@
 export * from './useIMBaseUrl';
+export * from './useIMFetchModuleState';
+export * from './useIMModuleInfo';

package/lib/packages/Tenant/hooks/index.js

@@ -1 +1,3 @@
 export * from './useIMBaseUrl';
+export * from './useIMFetchModuleState';
+export * from './useIMModuleInfo';

package/lib/packages/Tenant/hooks/useIMFetchModuleState.d.ts

@@ -0,0 +1,2 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useIMFetchModuleState: (Context?: typeof DefaultContext) => import("..").FetchModuleState;

package/lib/packages/Tenant/hooks/useIMFetchModuleState.js

@@ -0,0 +1,22 @@
+import { useContext, useEffect, useReducer, useRef } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMTenantError } from '../IMTenantError';
+export const useIMFetchModuleState = (Context) => {
+    const initRef = useRef(true);
+    const [, forceRender] = useReducer((s) => s + 1, 0);
+    const tenantContext = useContext(Context || DefaultContext);
+    if (tenantContext == null) {
+        throw new IMTenantError('useIMFetchModuleState requires either a Context provide or an ancestor element with a IMTenantProvider.');
+    }
+    if (initRef.current) {
+        initRef.current = false;
+        tenantContext.modulesStateRenderTarget.addEventListener(forceRender);
+    }
+    useEffect(() => {
+        return () => {
+            tenantContext.modulesStateRenderTarget.removeEventListener(forceRender);
+        };
+    }, []);
+    const state = tenantContext.getFetchModuleState();
+    return state;
+};

package/lib/packages/Tenant/hooks/useIMModuleInfo.d.ts

@@ -0,0 +1,6 @@
+import { Context as DefaultContext } from '../Context';
+export declare const useIMModuleInfo: (Context?: typeof DefaultContext) => {
+    fetchModuleInfo: () => Promise<void>;
+    getModuleInfo: () => import("..").Moudles | undefined;
+    destroyModuleInfo: () => Promise<void>;
+};

package/lib/packages/Tenant/hooks/useIMModuleInfo.js

@@ -0,0 +1,13 @@
+import { useContext, useMemo } from 'react';
+import { Context as DefaultContext } from '../Context';
+import { IMTenantError } from '../IMTenantError';
+export const useIMModuleInfo = (Context) => {
+    const tenantContext = useContext(Context || DefaultContext);
+    if (tenantContext == null) {
+        throw new IMTenantError('useIMModuleInfo requires either a Context provide or an ancestor element with a IMTenantProvider.');
+    }
+    return useMemo(() => {
+        const { fetchModuleInfo, getModuleInfo, destroyModuleInfo } = tenantContext;
+        return { fetchModuleInfo, getModuleInfo, destroyModuleInfo };
+    }, [tenantContext]);
+};

package/lib/packages/Tenant/index.d.ts

@@ -1,10 +1,25 @@
 /// <reference types="react" />
 import { Context as DefaultContext } from './Context';
+import { ModuleIds } from './modulesType';
 interface IMTenantProps {
     children: JSX.Element;
     baseUrl: string;
     tenantId?: string;
     tenantContext?: typeof DefaultContext;
+    useModuleInfo?: boolean;
 }
-export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, }: IMTenantProps) => import("react").JSX.Element;
+export interface ModuleInfo<T extends ModuleIds[number]> {
+    moduleKey: T;
+    enabled: boolean;
+    othes: unknown;
+}
+export type Moudles = {
+    [key in ModuleIds[number]]: ModuleInfo<key>;
+};
+export type FetchModuleState = 'notRequired' | 'notFetched' | 'fetched';
+export interface ModuleState {
+    fetchModuleState: FetchModuleState;
+    modules?: Moudles;
+}
+export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, useModuleInfo, }: IMTenantProps) => import("react").JSX.Element;
 export {};

package/lib/packages/Tenant/index.js

@@ -1,19 +1,117 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import { useCallback, useRef } from 'react';
+import { useRenderTarget } from '../../_shared/renderTarget';
+import { join } from '../../utils/path';
 import { Context as DefaultContext } from './Context';
+import { IMTenantError } from './IMTenantError';
+import { HYBRID_SSO_KEY, MODULE_IDS } from './modulesType';
 const useGetBaseUrl = (baseUrl) => {
     return useCallback(() => baseUrl, [baseUrl]);
 };
 const useGetTenantId = (tenantId) => {
     return useCallback(() => tenantId, [tenantId]);
 };
-export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, }) => {
+const createInitFetchModuleState = (useModuleInfo) => {
+    return useModuleInfo ? 'notFetched' : 'notRequired';
+};
+const useStorageKey = (baseUrl, moduleKey) => {
+    return `${baseUrl}_${moduleKey}`;
+};
+const saveModuleInfoStorage = async (storageKey, ModuleInfo) => {
+    return await AsyncStorage.setItem(storageKey, JSON.stringify(ModuleInfo));
+};
+const deleteModuleInfoStorage = async (storageKey) => {
+    return await AsyncStorage.removeItem(storageKey);
+};
+const getModuleInfoStorage = async (storageKey) => {
+    const state = await AsyncStorage.getItem(storageKey);
+    if (state == null)
+        return;
+    const result = JSON.parse(state);
+    return result;
+};
+const useFetchModuleStateRef = (renderTarget, useModuleInfo) => {
+    const ref = useRef(createInitFetchModuleState(useModuleInfo));
+    const setter = useCallback((state, silent) => {
+        if (!useModuleInfo)
+            throw new IMTenantError('useModuleInfo is not enabled');
+        if (ref.current === state)
+            return;
+        ref.current = state;
+        if (!silent)
+            renderTarget.dispatch();
+    }, []);
+    const getter = useCallback(() => ref.current, []);
+    return [ref, setter, getter];
+};
+const useModuleInfoRef = (getBaseUrl, fetchModuleStateSetter, useModuleInfo) => {
+    const ref = useRef();
+    const setter = useCallback((state, silent) => {
+        if (!useModuleInfo)
+            throw new IMTenantError('useModuleInfo is not enabled');
+        if (ref.current === state)
+            return;
+        ref.current = state;
+        fetchModuleStateSetter('fetched', silent);
+    }, []);
+    const getter = useCallback(() => ref.current, []);
+    const destroy = useCallback(async () => {
+        for (let i = 0; i < MODULE_IDS.length; i++) {
+            const key = MODULE_IDS[i];
+            if (key) {
+                const storageKey = useStorageKey(getBaseUrl(), key);
+                await deleteModuleInfoStorage(storageKey);
+            }
+        }
+        ref.current = undefined;
+        fetchModuleStateSetter('notFetched');
+    }, []);
+    return [ref, setter, getter, destroy];
+};
+const useCheckHybridSSOUrl = (baseUrl) => {
+    return join(baseUrl, '/im_hybrid_sso/logout');
+};
+const useFetchModuleInfo = (getBaseUrl, setModuleInfo) => {
+    const hybridSSOUrl = useCheckHybridSSOUrl(getBaseUrl());
+    return useCallback(async () => {
+        const storageKey = useStorageKey(getBaseUrl(), HYBRID_SSO_KEY);
+        const storageState = await getModuleInfoStorage(storageKey);
+        if (storageState) {
+            setModuleInfo({
+                [HYBRID_SSO_KEY]: storageState,
+            });
+        }
+        else {
+            const response = await fetch(hybridSSOUrl);
+            const hasHyBridSSO = response.status !== 404;
+            const state = {
+                moduleKey: HYBRID_SSO_KEY,
+                enabled: hasHyBridSSO,
+                othes: {},
+            };
+            saveModuleInfoStorage(storageKey, state);
+            setModuleInfo({ [HYBRID_SSO_KEY]: state });
+        }
+    }, [setModuleInfo]);
+};
+export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, useModuleInfo, }) => {
     const Context = tenantContext || DefaultContext;
     const contextRef = useRef();
+    const modulesStateRenderTarget = useRenderTarget();
     const getBaseUrl = useGetBaseUrl(baseUrl);
     const getTenantId = useGetTenantId(tenantId);
+    const [, setFetchModuleState, getFetchModuleState] = useFetchModuleStateRef(modulesStateRenderTarget, useModuleInfo);
+    const [, setModuleInfo, getModuleInfo, destroyModuleInfo] = useModuleInfoRef(getBaseUrl, setFetchModuleState, useModuleInfo);
+    const fetchModuleInfo = useFetchModuleInfo(getBaseUrl, setModuleInfo);
+    saveModuleInfoStorage;
     contextRef.current = {
         getBaseUrl,
         getTenantId,
+        getFetchModuleState,
+        getModuleInfo,
+        destroyModuleInfo,
+        fetchModuleInfo,
+        modulesStateRenderTarget,
     };
     return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);
 };

package/lib/packages/Tenant/modulesType.d.ts

@@ -0,0 +1,3 @@
+export declare const HYBRID_SSO_KEY: "jp.co.intra_mart.im_hybrid_sso";
+export type ModuleIds = readonly [typeof HYBRID_SSO_KEY];
+export declare const MODULE_IDS: ModuleIds;

package/lib/packages/Tenant/modulesType.js

@@ -0,0 +1,2 @@
+export const HYBRID_SSO_KEY = 'jp.co.intra_mart.im_hybrid_sso';
+export const MODULE_IDS = [HYBRID_SSO_KEY];

package/lib/packages/WebView/InternalIMWebView.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { WebView, WebViewProps } from 'react-native-webview';
+import { WebViewSourceUri } from 'react-native-webview/lib/WebViewTypes';
+import { IMWebViewError } from './IMWebViewError';
+export type OnSessionCreationError = (error: IMWebViewError) => void;
+export interface InternalIMWebViewProps extends Omit<WebViewProps, 'onShouldStartLoadWithRequest'> {
+    source: WebViewSourceUri;
+    onSessionCreationError?: OnSessionCreationError;
+    indicator?: JSX.Element | null;
+    forceLogin?: boolean;
+}
+export declare const InternalIMWebView: React.ForwardRefExoticComponent<InternalIMWebViewProps & React.RefAttributes<WebView<{}>>>;
+export declare const internalIMWebViewStyles: {
+    indicator: {
+        position: "absolute";
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        alignItems: "center";
+        justifyContent: "center";
+        backgroundColor: string;
+    };
+};

package/lib/packages/WebView/InternalIMWebView.js

@@ -0,0 +1,205 @@
+import React, { useRef, useState } from 'react';
+import { ActivityIndicator, StyleSheet } from 'react-native';
+import { WebView } from 'react-native-webview';
+import { useIMBaseUrl, useIMToken } from '../..';
+import { mergeRef } from '../../utils/mergeRef';
+import { join } from '../../utils/path';
+import { useIMModuleInfo } from '../Tenant/hooks/useIMModuleInfo';
+import { HYBRID_SSO_KEY } from '../Tenant/modulesType';
+import { IMWebViewError } from './IMWebViewError';
+const IMAUTOLOGIN_SUCCESS = 'IMAUTOLOGIN_SUCCESS';
+const IMAUTOLOGIN_ERROR = 'IMAUTOLOGIN_ERROR';
+const useCheckSessionUrl = (baseUrl) => {
+    return join(baseUrl, '/api/smacolow/session');
+};
+const useSessionEstablishmentUrl = (baseUrl) => {
+    return join(baseUrl, '/api/bearer/smacolow/session');
+};
+const useLogoutUrl = (baseUrl) => {
+    const { getModuleInfo } = useIMModuleInfo();
+    const info = getModuleInfo();
+    if (info && info[HYBRID_SSO_KEY]) {
+        const hybridSSO = info[HYBRID_SSO_KEY];
+        if (hybridSSO.enabled)
+            return join(baseUrl, '/login');
+    }
+    return join(baseUrl, '/logout');
+};
+const useSessionEstablishmentScript = (sessionEstablishmentUrl, token) => {
+    return `
+fetch('${sessionEstablishmentUrl}', {
+  headers: {
+    'X-Intramart-Session': 'keep',
+    Authorization: 'Bearer ${token}',
+  },
+}).then((state) => {
+    if(state.status === 200) window.ReactNativeWebView.postMessage('${IMAUTOLOGIN_SUCCESS}');
+    else window.ReactNativeWebView.postMessage('${IMAUTOLOGIN_ERROR}');
+  }).catch(() => {
+    window.ReactNativeWebView.postMessage('${IMAUTOLOGIN_ERROR}');
+  });
+true;
+`;
+};
+const useLogin = (props, webviewRef) => {
+    const baseUrl = useIMBaseUrl();
+    const token = useIMToken();
+    const targetUrl = props.source.uri;
+    const checkSessionUrl = useCheckSessionUrl(baseUrl);
+    const sessionEstablishmentUrl = useSessionEstablishmentUrl(baseUrl);
+    const logoutUrl = useLogoutUrl(baseUrl);
+    const initialUrlRef = useRef(props.forceLogin ? logoutUrl : checkSessionUrl);
+    const currentUrlRef = useRef(initialUrlRef.current);
+    const isCheckSessionErrorRef = useRef(false);
+    const [isFailedLogin, setIsFailedLogin] = useState(false);
+    const [isLogin, setIsLogin] = useState(false);
+    const [isTargetUrl, setIsTargetUrl] = useState(false);
+    const sessionEstablishmentScript = useSessionEstablishmentScript(sessionEstablishmentUrl, token);
+    const onHttpError = (event) => {
+        if (currentUrlRef.current === checkSessionUrl &&
+            event.nativeEvent.statusCode === 401) {
+            isCheckSessionErrorRef.current = true;
+        }
+        else if (currentUrlRef.current === targetUrl) {
+            if (props.onHttpError)
+                props.onHttpError(event);
+        }
+        else {
+            setIsFailedLogin(true);
+            if (props.onSessionCreationError) {
+                props.onSessionCreationError(new IMWebViewError('http error occurred during auto login.'));
+            }
+        }
+    };
+    const onShouldStartLoadWithRequest = (request) => {
+        if (isLogin || isTargetUrl)
+            return true;
+        if (currentUrlRef.current === checkSessionUrl) {
+            if (request.url === logoutUrl || request.url === checkSessionUrl)
+                return true;
+        }
+        if (currentUrlRef.current === logoutUrl) {
+            if (request.url === targetUrl || request.url === logoutUrl)
+                return true;
+        }
+        if (currentUrlRef.current === targetUrl) {
+            if (request.url === targetUrl)
+                return true;
+        }
+        return false;
+    };
+    const onLoadStart = (event) => {
+        if (currentUrlRef.current === targetUrl && !isLogin) {
+            if (props.onLoadStart)
+                props.onLoadStart(event);
+        }
+    };
+    const onLoadEnd = (event) => {
+        if (currentUrlRef.current === targetUrl && !isLogin) {
+            if (props.onLoadEnd)
+                props.onLoadEnd(event);
+        }
+    };
+    const onLoadProgress = (event) => {
+        if (currentUrlRef.current === targetUrl && !isLogin) {
+            if (props.onLoadProgress)
+                props.onLoadProgress(event);
+        }
+    };
+    const onLoad = (event) => {
+        if (isLogin || isFailedLogin)
+            return;
+        if ((isCheckSessionErrorRef.current === false &&
+            currentUrlRef.current === checkSessionUrl) ||
+            currentUrlRef.current === sessionEstablishmentUrl) {
+            setIsTargetUrl(true);
+            currentUrlRef.current = targetUrl;
+            webviewRef.current?.injectJavaScript(`
+        location.replace('${targetUrl}');
+        true;
+      `);
+        }
+        else if (isCheckSessionErrorRef.current === true &&
+            checkSessionUrl === currentUrlRef.current) {
+            currentUrlRef.current = logoutUrl;
+            webviewRef.current?.injectJavaScript(`
+        location.replace('${logoutUrl}');
+        true;
+      `);
+        }
+        else if (currentUrlRef.current === logoutUrl) {
+            const url = new URL(event.nativeEvent.url);
+            // because im_hybrid_sso may be called in the logoutUrl as an iframe when IM-HybridSSO is enabled
+            if (join(url.origin, url.pathname).replace(/\/$/, '') === logoutUrl) {
+                webviewRef.current?.injectJavaScript(sessionEstablishmentScript);
+            }
+        }
+        else if (currentUrlRef.current === targetUrl && !isLogin) {
+            setIsLogin(true);
+            if (props.onLoad)
+                props.onLoad(event);
+        }
+    };
+    const onMessage = (event) => {
+        if (currentUrlRef.current === targetUrl && props.onMessage)
+            props.onMessage(event);
+        if (event.nativeEvent.data === IMAUTOLOGIN_SUCCESS) {
+            setIsTargetUrl(true);
+            currentUrlRef.current = targetUrl;
+            webviewRef.current?.injectJavaScript(`
+        location.replace('${targetUrl}');
+      `);
+        }
+        if (event.nativeEvent.data === IMAUTOLOGIN_ERROR) {
+            setIsFailedLogin(true);
+            if (props.onSessionCreationError) {
+                props.onSessionCreationError(new IMWebViewError('http error occurred during auto login.'));
+            }
+        }
+    };
+    const autoLoginProps = {
+        source: {
+            uri: initialUrlRef.current,
+        },
+        sharedCookiesEnabled: false,
+        onLoad,
+        onLoadStart,
+        onLoadEnd,
+        onLoadProgress,
+        onHttpError,
+        onMessage,
+        onShouldStartLoadWithRequest,
+    };
+    const webviewProps = isLogin
+        ? props
+        : isTargetUrl
+            ? { ...props, ...autoLoginProps }
+            : autoLoginProps;
+    return {
+        isLogin,
+        isFailedLogin,
+        webviewProps,
+    };
+};
+export const InternalIMWebView = React.forwardRef((props, ref) => {
+    const webviewRef = useRef(null);
+    const margedRef = mergeRef(ref, webviewRef);
+    const { isLogin, isFailedLogin, webviewProps } = useLogin(props, webviewRef);
+    const indicator = isLogin && !isFailedLogin ? null : props.indicator !== void 0 ? (props.indicator) : (<ActivityIndicator style={internalIMWebViewStyles.indicator}/>);
+    return (<>
+        <WebView ref={margedRef} {...webviewProps}/>
+        {indicator}
+      </>);
+});
+export const internalIMWebViewStyles = StyleSheet.create({
+    indicator: {
+        position: 'absolute',
+        left: 0,
+        right: 0,
+        top: 0,
+        bottom: 0,
+        alignItems: 'center',
+        justifyContent: 'center',
+        backgroundColor: 'gray',
+    },
+});

package/lib/packages/WebView/index.d.ts

@@ -1,12 +1,6 @@
 import React from 'react';
-import { WebView, WebViewProps } from 'react-native-webview';
-import { WebViewSourceUri } from 'react-native-webview/lib/WebViewTypes';
-import { IMWebViewError } from './IMWebViewError';
-export type OnSessionCreationError = (error: IMWebViewError) => void;
-export interface IMWebViewProps extends Omit<WebViewProps, 'onShouldStartLoadWithRequest'> {
-    source: WebViewSourceUri;
-    onSessionCreationError?: OnSessionCreationError;
-    indicator?: JSX.Element | null;
-    forceLogin?: boolean;
+import { WebView } from 'react-native-webview';
+import { InternalIMWebViewProps } from './InternalIMWebView';
+export interface IMWebViewProps extends InternalIMWebViewProps {
 }
 export declare const IMWebView: React.ForwardRefExoticComponent<IMWebViewProps & React.RefAttributes<WebView<{}>>>;

package/lib/packages/WebView/index.js

@@ -1,171 +1,30 @@
-import React, { useRef, useState } from 'react';
-import { ActivityIndicator, StyleSheet } from 'react-native';
-import { WebView } from 'react-native-webview';
-import { useIMBaseUrl, useIMToken } from '../..';
-import { mergeRef } from '../../utils/mergeRef';
-import { join } from '../../utils/path';
+import React, { useRef } from 'react';
+import { ActivityIndicator, View } from 'react-native';
+import { useIMFetchModuleState } from '../Tenant/hooks/useIMFetchModuleState';
+import { useIMModuleInfo } from '../Tenant/hooks/useIMModuleInfo';
 import { IMWebViewError } from './IMWebViewError';
-const IMAUTOLOGIN_SUCCESS = 'IMAUTOLOGIN_SUCCESS';
-const IMAUTOLOGIN_ERROR = 'IMAUTOLOGIN_ERROR';
-const useCheckSessionUrl = (baseUrl) => {
-    return join(baseUrl, '/api/smacolow/session');
-};
-const useGetSessionUrl = (baseUrl) => {
-    return join(baseUrl, '/api/bearer/smacolow/session');
-};
-const useLogoutUrl = (baseUrl) => {
-    return join(baseUrl, '/logout');
-};
-const useLogin = (props, webviewRef) => {
-    const baseUrl = useIMBaseUrl();
-    const token = useIMToken();
-    const targetUrl = props.source.uri;
-    const checkSessionUrl = useCheckSessionUrl(baseUrl);
-    const getSessionUrl = useGetSessionUrl(baseUrl);
-    const logoutUrl = useLogoutUrl(baseUrl);
-    const initialUrlRef = useRef(props.forceLogin ? logoutUrl : checkSessionUrl);
-    const currentUrlRef = useRef(initialUrlRef.current);
-    const isCheckSessionErrorRef = useRef(false);
-    const [isFailedLogin, setIsFailedLogin] = useState(false);
-    const [isLogin, setIsLogin] = useState(false);
-    const [isTargetUrl, setIsTargetUrl] = useState(false);
-    const onHttpError = (event) => {
-        if (currentUrlRef.current === checkSessionUrl &&
-            event.nativeEvent.statusCode === 401) {
-            isCheckSessionErrorRef.current = true;
-        }
-        else if (currentUrlRef.current === targetUrl) {
-            if (props.onHttpError)
-                props.onHttpError(event);
-        }
-        else {
-            setIsFailedLogin(true);
-            if (props.onSessionCreationError) {
-                props.onSessionCreationError(new IMWebViewError('http error occurred during auto login.'));
+import { InternalIMWebView, internalIMWebViewStyles, } from './InternalIMWebView';
+const useInitModuleState = (onSessionCreationError) => {
+    const initRef = useRef(true);
+    const fetchModuleState = useIMFetchModuleState();
+    const { fetchModuleInfo } = useIMModuleInfo();
+    if (fetchModuleState === 'notFetched' && initRef.current) {
+        initRef.current = false;
+        (async () => {
+            try {
+                await fetchModuleInfo();
             }
-        }
-    };
-    const onShouldStartLoadWithRequest = (request) => {
-        if (isLogin || isTargetUrl)
-            return true;
-        if (currentUrlRef.current === checkSessionUrl) {
-            if (request.url === logoutUrl || request.url === checkSessionUrl)
-                return true;
-        }
-        if (currentUrlRef.current === logoutUrl) {
-            if (request.url === targetUrl || request.url === logoutUrl)
-                return true;
-        }
-        if (currentUrlRef.current === targetUrl) {
-            if (request.url === targetUrl)
-                return true;
-        }
-        return false;
-    };
-    const onLoad = (event) => {
-        if (isLogin || isFailedLogin)
-            return;
-        if ((isCheckSessionErrorRef.current === false &&
-            currentUrlRef.current === checkSessionUrl) ||
-            currentUrlRef.current === getSessionUrl) {
-            setIsTargetUrl(true);
-            currentUrlRef.current = targetUrl;
-            webviewRef.current?.injectJavaScript(`
-        location.replace('${targetUrl}');
-        true;
-      `);
-        }
-        else if (isCheckSessionErrorRef.current === true &&
-            checkSessionUrl === currentUrlRef.current) {
-            currentUrlRef.current = logoutUrl;
-            webviewRef.current?.injectJavaScript(`
-        location.replace('${logoutUrl}');
-        true;
-      `);
-        }
-        else if (currentUrlRef.current === logoutUrl) {
-            const url = new URL(event.nativeEvent.url);
-            // because im_hybrid_sso may be called in the logoutUrl as an iframe when IM-HybridSSO is enabled
-            if (join(url.origin, url.pathname).replace(/\/$/, '') === logoutUrl) {
-                webviewRef.current?.injectJavaScript(`
-        fetch('${getSessionUrl}', {
-          headers: {
-            'X-Intramart-Session': 'keep',
-            Authorization: 'Bearer ${token}',
-          },
-        }).then((state) => {
-            if(state.status === 200) window.ReactNativeWebView.postMessage('${IMAUTOLOGIN_SUCCESS}');
-            else window.ReactNativeWebView.postMessage('${IMAUTOLOGIN_ERROR}');
-          }).catch(() => {
-            window.ReactNativeWebView.postMessage('${IMAUTOLOGIN_ERROR}');
-          });
-        true;
-      `);
+            catch (error) {
+                onSessionCreationError?.(new IMWebViewError('failed to fetch module status.'));
             }
-        }
-        else if (currentUrlRef.current === targetUrl && !isLogin) {
-            setIsLogin(true);
-            if (props.onLoad)
-                props.onLoad(event);
-        }
-    };
-    const onMessage = (event) => {
-        if (currentUrlRef.current === targetUrl && props.onMessage)
-            props.onMessage(event);
-        if (event.nativeEvent.data === IMAUTOLOGIN_SUCCESS) {
-            setIsTargetUrl(true);
-            currentUrlRef.current = targetUrl;
-            webviewRef.current?.injectJavaScript(`
-        location.replace('${targetUrl}');
-      `);
-        }
-        if (event.nativeEvent.data === IMAUTOLOGIN_ERROR) {
-            setIsFailedLogin(true);
-            if (props.onSessionCreationError) {
-                props.onSessionCreationError(new IMWebViewError('http error occurred during auto login.'));
-            }
-        }
-    };
-    const autoLoginProps = {
-        source: {
-            uri: initialUrlRef.current,
-        },
-        sharedCookiesEnabled: false,
-        onLoad,
-        onHttpError,
-        onMessage,
-        onShouldStartLoadWithRequest,
-    };
-    const webviewProps = isLogin
-        ? props
-        : isTargetUrl
-            ? { ...props, ...autoLoginProps }
-            : autoLoginProps;
-    return {
-        isLogin,
-        isFailedLogin,
-        webviewProps,
-    };
+        })();
+    }
+    return fetchModuleState;
 };
 export const IMWebView = React.forwardRef((props, ref) => {
-    const webviewRef = useRef(null);
-    const margedRef = mergeRef(ref, webviewRef);
-    const { isLogin, isFailedLogin, webviewProps } = useLogin(props, webviewRef);
-    const indicator = isLogin && !isFailedLogin ? null : props.indicator !== void 0 ? (props.indicator) : (<ActivityIndicator style={styles.indicator}/>);
-    return (<>
-        <WebView ref={margedRef} {...webviewProps}/>
-        {indicator}
+    const moduleState = useInitModuleState(props.onSessionCreationError);
+    return moduleState !== 'notFetched' ? (<InternalIMWebView ref={ref} {...props}/>) : (<>
+        <View style={props.style}/>
+        <ActivityIndicator style={internalIMWebViewStyles.indicator}/>
       </>);
 });
-const styles = StyleSheet.create({
-    indicator: {
-        position: 'absolute',
-        left: 0,
-        right: 0,
-        top: 0,
-        bottom: 0,
-        alignItems: 'center',
-        justifyContent: 'center',
-        backgroundColor: 'gray',
-    },
-});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@intra-mart/smartlime",
   "description": "expoで使用できるintra mart accelplatform SDK",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "keywords": [
     "intra-mart",
     "AccelPlatform",
@@ -50,6 +50,7 @@
     "expo-auth-session": "~5.4.0",
     "expo-crypto": "~12.8.0",
     "expo-random": "~13.6.0",
+    "expo-secure-store": "^13.0.1",
     "react-native-webview": "13.6.4",
     "set-cookie-parser": "^2.6.0"
   },