@intra-mart/smartlime 2.0.0-dev.20241210 → 2.0.0-dev.20251017

package/lib/packages/OAuth/index.js

@@ -1,16 +1,16 @@
-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';
-import { IMOAuthError } from './IMOAuthError';
-import { useRenderTarget } from '../../_shared/renderTarget';
+import * as SecureStore from 'expo-secure-store';
+import * as WebBrowser from 'expo-web-browser';
+import { useCallback, useEffect, useMemo, useRef, } from 'react';
 import { useIMBaseUrl } from '../..';
+import { useRenderTarget } from '../../_shared/renderTarget';
 import { join } from '../../utils/path';
-import * as WebBrowser from 'expo-web-browser';
+import { Context as DefaultContext, } from './Context';
+import { IMOAuthError } from './IMOAuthError';
 WebBrowser.maybeCompleteAuthSession();
 const SUCCESS = 'success';
 const EXCEPTION = 'exception';
-const DEFAULT_STORAGE_KEY = '_example_IMAuthKey';
+const DEFAULT_STORE_KEY = '_example_IMAuthKey';
 const DEFAULT_REMAINING_TIME_TO_RUN_REFRESH = 360000;
 export const IMPrompt = {
     Login: Prompt.Login,
@@ -51,10 +51,17 @@ const useDiscovery = () => {
         };
     }, [encodedBaseUrl]);
 };
-const useStorageKey = (storageKey) => {
+const useStoreConfig = (secureStore) => {
+    const storeKey = secureStore?.storeKey;
+    const keychainAccessible = secureStore?.keychainAccessible;
     return useMemo(() => {
-        return storageKey ? storageKey : DEFAULT_STORAGE_KEY;
-    }, [storageKey]);
+        return {
+            storeKey: storeKey ? storeKey : DEFAULT_STORE_KEY,
+            keychainAccessible: keychainAccessible !== void 0
+                ? keychainAccessible
+                : SecureStore.WHEN_UNLOCKED,
+        };
+    }, [storeKey, keychainAccessible]);
 };
 const useRemainingTimeToRunRefresh = (remainingTimeToRunRefresh) => {
     return useMemo(() => {
@@ -63,20 +70,26 @@ const useRemainingTimeToRunRefresh = (remainingTimeToRunRefresh) => {
             : DEFAULT_REMAINING_TIME_TO_RUN_REFRESH;
     }, [remainingTimeToRunRefresh]);
 };
-const saveTokenStorage = async (storageKey, baseUrl, accessToken, refreshToken, expirationDate) => {
+const saveTokenStore = async (storeConfig, baseUrl, accessToken, refreshToken, expirationDate) => {
     const item = {
         baseUrl,
         accessToken,
         refreshToken,
         expirationDate,
     };
-    return await SecureStore.setItemAsync(storageKey, JSON.stringify(item));
+    return await SecureStore.setItemAsync(storeConfig.storeKey, JSON.stringify(item), {
+        keychainAccessible: storeConfig.keychainAccessible,
+    });
 };
-const deleteTokenStorage = async (tokenStorageKey) => {
-    return await SecureStore.deleteItemAsync(tokenStorageKey);
+const deleteTokenStore = async (storeConfig) => {
+    return await SecureStore.deleteItemAsync(storeConfig.storeKey, {
+        keychainAccessible: storeConfig.keychainAccessible,
+    });
 };
-const getTokenStorage = async (storageKey) => {
-    const state = await SecureStore.getItemAsync(storageKey);
+const getTokenStore = async (storeConfig) => {
+    const state = await SecureStore.getItemAsync(storeConfig.storeKey, {
+        keychainAccessible: storeConfig.keychainAccessible,
+    });
     if (state == null)
         return;
     const result = JSON.parse(state);
@@ -116,7 +129,7 @@ const checkExpirationDateOfToken = (expirationDate, remainingTimeToRunRefresh) =
         return true;
     return false;
 };
-const useRefresh = (storageKey, refreshTokenRef, expirationDateRef, requestConfig, discovery, setToken, destroy) => {
+const useRefresh = (storeConfig, refreshTokenRef, expirationDateRef, requestConfig, discovery, setToken, destroy) => {
     const baseUrl = useIMBaseUrl();
     const lockedRef = useRef(false);
     const waitingLineRef = useRef([]);
@@ -163,7 +176,7 @@ const useRefresh = (storageKey, refreshTokenRef, expirationDateRef, requestConfi
                 }, discovery);
                 const { accessToken, refreshToken, expiresIn } = tokenResponse;
                 const expirationDate = expiresIn ? createExpirationDate(expiresIn) : 0;
-                await saveTokenStorage(storageKey, baseUrl, accessToken, refreshToken, expirationDate);
+                await saveTokenStore(storeConfig, baseUrl, accessToken, refreshToken, expirationDate);
                 refreshTokenRef.current = refreshToken ? refreshToken : null;
                 expirationDateRef.current = expirationDate;
                 setToken(accessToken);
@@ -178,36 +191,49 @@ const useRefresh = (storageKey, refreshTokenRef, expirationDateRef, requestConfi
                 throw error;
             }
         }
-    }, [storageKey, requestConfig, discovery, destroy]);
+    }, [storeConfig, requestConfig, discovery, destroy]);
 };
-const useStartAuth = (storageKey, remainingTimeToRunRefresh, refreshTokenRef, expirationDateRef, requestConfig, discovery, setToken, refresh, setAuthState) => {
+const useStartAuth = (storeConfig, remainingTimeToRunRefresh, refreshTokenRef, expirationDateRef, requestConfig, discovery, setToken, refresh, setAuthState, authErrorRenderTarget) => {
     const currentBaseUrl = useIMBaseUrl();
-    useLayoutEffect(() => {
+    useEffect(() => {
         (async () => {
-            const tokenState = await getTokenStorage(storageKey);
-            if (tokenState) {
-                const { baseUrl, accessToken, refreshToken, expirationDate } = tokenState;
-                const expired = checkExpirationDateOfToken(expirationDate ? expirationDate : 0, remainingTimeToRunRefresh);
-                refreshTokenRef.current = refreshToken ? refreshToken : null;
-                expirationDateRef.current = expirationDate ? expirationDate : null;
-                if (currentBaseUrl === baseUrl) {
-                    if (expired) {
-                        await refresh(); // NOTE consideration of how users can catch errors thrown here.
+            try {
+                const tokenState = await getTokenStore(storeConfig);
+                if (tokenState) {
+                    const { baseUrl, accessToken, refreshToken, expirationDate } = tokenState;
+                    const expired = checkExpirationDateOfToken(expirationDate ? expirationDate : 0, remainingTimeToRunRefresh);
+                    refreshTokenRef.current = refreshToken ? refreshToken : null;
+                    expirationDateRef.current = expirationDate ? expirationDate : null;
+                    if (currentBaseUrl === baseUrl) {
+                        if (expired) {
+                            await refresh(); // NOTE consideration of how users can catch errors thrown here.
+                        }
+                        else {
+                            setToken(accessToken);
+                        }
+                        setAuthState('authorized');
                     }
                     else {
-                        setToken(accessToken);
+                        setAuthState('unauthorized');
                     }
-                    setAuthState('authorized');
                 }
                 else {
                     setAuthState('unauthorized');
                 }
             }
-            else {
+            catch (e) {
                 setAuthState('unauthorized');
+                authErrorRenderTarget.dispatch(new IMOAuthError('an exception occurred while checking the token state.', {
+                    cause: e,
+                }));
             }
         })();
-    }, [storageKey, remainingTimeToRunRefresh, refresh]);
+    }, [
+        storeConfig.storeKey,
+        storeConfig.keychainAccessible,
+        remainingTimeToRunRefresh,
+        refresh,
+    ]);
     const startAuth = useCallback(async () => {
         const authRequest = await loadAsync({
             ...requestConfig,
@@ -236,7 +262,7 @@ const useStartAuth = (storageKey, remainingTimeToRunRefresh, refreshTokenRef, ex
             }, discovery);
             const { accessToken, refreshToken, expiresIn } = tokenResponse;
             const expirationDate = expiresIn ? createExpirationDate(expiresIn) : 0;
-            await saveTokenStorage(storageKey, currentBaseUrl, accessToken, refreshToken, expirationDate);
+            await saveTokenStore(storeConfig, currentBaseUrl, accessToken, refreshToken, expirationDate);
             refreshTokenRef.current = refreshToken ? refreshToken : null;
             expirationDateRef.current = expirationDate;
             setToken(accessToken);
@@ -256,14 +282,14 @@ const useStartAuth = (storageKey, remainingTimeToRunRefresh, refreshTokenRef, ex
     }, [requestConfig, discovery]);
     return startAuth;
 };
-const useDestroy = (storageKey, refreshTokenRef, expirationDateRef, setToken, setAuthState) => {
+const useDestroy = (storeConfig, refreshTokenRef, expirationDateRef, setToken, setAuthState) => {
     return useCallback(async () => {
-        await deleteTokenStorage(storageKey);
+        await deleteTokenStore(storeConfig);
         setToken(null);
         refreshTokenRef.current = null;
         expirationDateRef.current = null;
         setAuthState('unauthorized');
-    }, [storageKey, setAuthState]);
+    }, [storeConfig, setAuthState]);
 };
 const useGetTokenAsync = (tokenRef, expirationDateRef, remainingTimeToRunRefresh, refresh) => {
     return useCallback(async () => {
@@ -276,22 +302,23 @@ const useGetTokenAsync = (tokenRef, expirationDateRef, remainingTimeToRunRefresh
         return tokenRef.current;
     }, [refresh]);
 };
-export const IMOAuth = ({ children, requestConfig, remainingTimeToRunRefresh, storageKey, oauthContext, }) => {
+export const IMOAuth = ({ children, requestConfig, remainingTimeToRunRefresh, secureStore, oauthContext, }) => {
     const Context = oauthContext || DefaultContext;
-    const contextRef = useRef();
+    const contextRef = useRef(null);
     const authStateRenderTarget = useRenderTarget();
     const [, setAuthState, getAuthState] = useAuthStateRef(authStateRenderTarget);
     const tokenRenderTarget = useRenderTarget();
     const [tokenRef, setToken, getToken] = useTokenRef(tokenRenderTarget);
     const refreshTokenRef = useRef(null);
     const expirationDateRef = useRef(null);
-    const _storageKey = useStorageKey(storageKey);
+    const storeConfig = useStoreConfig(secureStore);
     const _remainingTimeToRunRefresh = useRemainingTimeToRunRefresh(remainingTimeToRunRefresh);
     const _requestConfig = useRequestConfig(requestConfig);
     const _discovery = useDiscovery();
-    const destroy = useDestroy(_storageKey, refreshTokenRef, expirationDateRef, setToken, setAuthState);
-    const refresh = useRefresh(_storageKey, refreshTokenRef, expirationDateRef, _requestConfig, _discovery, setToken, destroy);
-    const startAuth = useStartAuth(_storageKey, _remainingTimeToRunRefresh, refreshTokenRef, expirationDateRef, _requestConfig, _discovery, setToken, refresh, setAuthState);
+    const authErrorRenderTarget = useRenderTarget();
+    const destroy = useDestroy(storeConfig, refreshTokenRef, expirationDateRef, setToken, setAuthState);
+    const refresh = useRefresh(storeConfig, refreshTokenRef, expirationDateRef, _requestConfig, _discovery, setToken, destroy);
+    const startAuth = useStartAuth(storeConfig, _remainingTimeToRunRefresh, refreshTokenRef, expirationDateRef, _requestConfig, _discovery, setToken, refresh, setAuthState, authErrorRenderTarget);
     const getTokenAsync = useGetTokenAsync(tokenRef, expirationDateRef, _remainingTimeToRunRefresh, refresh);
     contextRef.current = {
         getAuthState,
@@ -302,6 +329,7 @@ export const IMOAuth = ({ children, requestConfig, remainingTimeToRunRefresh, st
         startAuth,
         tokenRenderTarget,
         authStateRenderTarget,
+        authErrorRenderTarget,
     };
     return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);
 };

package/lib/packages/Search/hooks/useDepartmentPostSearch.d.ts

@@ -1,2 +1,3 @@
 import { DepartmentPostDepartmentSet, DepartmentPostSearchResult } from '../types';
-export declare const useDepartmentPostSearch: (paramString: string) => (departmentSet: DepartmentPostDepartmentSet, init?: RequestInit) => Promise<DepartmentPostSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useDepartmentPostSearch: (paramString: string) => (departmentSet: DepartmentPostDepartmentSet, init?: FetchRequestInit) => Promise<DepartmentPostSearchResult>;

package/lib/packages/Search/hooks/useDepartmentSearch.d.ts

@@ -1,2 +1,3 @@
 import { DepartmentSearcResult } from '../types';
-export declare const useDepartmentSearch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<DepartmentSearcResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useDepartmentSearch: (paramString: string) => (keyword: string, init?: FetchRequestInit) => Promise<DepartmentSearcResult>;

package/lib/packages/Search/hooks/useDepartmentTopSearch.d.ts

@@ -1,2 +1,3 @@
 import { DepartmentTopSearcResult } from '../types';
-export declare const useDepartmentTopSearch: (paramString: string) => (init?: RequestInit) => Promise<DepartmentTopSearcResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useDepartmentTopSearch: (paramString: string) => (init?: FetchRequestInit) => Promise<DepartmentTopSearcResult>;

package/lib/packages/Search/hooks/usePostSearch.d.ts

@@ -1,2 +1,3 @@
 import { DepartmentSet, PostSearcResult } from '../types';
-export declare const usePostSearch: (paramString: string) => (departmentSet: DepartmentSet, init?: RequestInit) => Promise<PostSearcResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePostSearch: (paramString: string) => (departmentSet: DepartmentSet, init?: FetchRequestInit) => Promise<PostSearcResult>;

package/lib/packages/Search/hooks/usePublicGroupRoleSearch.d.ts

@@ -1,2 +1,3 @@
 import { PublicGroupRoleSearchResult, PublicGroupRoleSet } from '../types';
-export declare const usePublicGroupRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupRoleSet, init?: RequestInit) => Promise<PublicGroupRoleSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePublicGroupRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupRoleSet, init?: FetchRequestInit) => Promise<PublicGroupRoleSearchResult>;

package/lib/packages/Search/hooks/usePublicGroupSearch.d.ts

@@ -1,2 +1,3 @@
 import { PublicGroupSearcResult } from '../types';
-export declare const usePublicGroupSearch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<PublicGroupSearcResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePublicGroupSearch: (paramString: string) => (keyword: string, init?: FetchRequestInit) => Promise<PublicGroupSearcResult>;

package/lib/packages/Search/hooks/usePublicGroupTopSearch.d.ts

@@ -1,2 +1,3 @@
 import { PublicGroupTopSearchResult } from '../types';
-export declare const usePublicGroupTopSearch: (paramString: string) => (init?: RequestInit) => Promise<PublicGroupTopSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const usePublicGroupTopSearch: (paramString: string) => (init?: FetchRequestInit) => Promise<PublicGroupTopSearchResult>;

package/lib/packages/Search/hooks/useRoleSearch.d.ts

@@ -1,2 +1,3 @@
 import { PublicGroupSet, RoleSearchResult } from '../types';
-export declare const useRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupSet, init?: RequestInit) => Promise<RoleSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupSet, init?: FetchRequestInit) => Promise<RoleSearchResult>;

package/lib/packages/Search/hooks/useUserAdditionalInformationSearch.d.ts

@@ -1,2 +1,3 @@
 import { UserAdditionalInformationSearchResult } from '../types';
-export declare const useUserAdditionalInformationSearch: (paramString: string) => (userCd: string, init?: RequestInit) => Promise<UserAdditionalInformationSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useUserAdditionalInformationSearch: (paramString: string) => (userCd: string, init?: FetchRequestInit) => Promise<UserAdditionalInformationSearchResult>;

package/lib/packages/Search/hooks/useUserSearch.d.ts

@@ -1,2 +1,3 @@
 import { UserSearchResult } from '../types';
-export declare const useUserSearch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<UserSearchResult>;
+import { FetchRequestInit } from 'expo/fetch';
+export declare const useUserSearch: (paramString: string) => (keyword: string, init?: FetchRequestInit) => Promise<UserSearchResult>;

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

@@ -1,8 +1,9 @@
+import { JSX } from 'react';
 import { Context as DefaultContext } from './Context';
 import { DepartmentPostSearchRecord, DepartmentSearchRecord, PostSearchRecord, PublicGroupSearchRecord, RoleSearchRecord, UserSearchRecord } from './types';
 export type SearchTarget = 'jp.co.intra_mart.master.search.user' | 'jp.co.intra_mart.master.search.company' | 'jp.co.intra_mart.master.search.company_post' | 'jp.co.intra_mart.master.search.department' | 'jp.co.intra_mart.master.search.public_group' | 'jp.co.intra_mart.master.search.private_group' | 'jp.co.intra_mart.master.search.public_group_role' | 'jp.co.intra_mart.master.search.role' | 'jp.co.intra_mart.master.search.attached_department_post' | 'jp.co.intra_mart.master.search.attached_public_group_role' | undefined;
 export type SearchType = 'single' | 'multiple';
-declare const useLock: () => import("react").MutableRefObject<boolean>;
+declare const useLock: () => import("react").RefObject<boolean>;
 declare const useVisible: () => [boolean, import("react").Dispatch<import("react").SetStateAction<boolean>>];
 declare const useSearchTarget: () => [SearchTarget, import("react").Dispatch<import("react").SetStateAction<SearchTarget>>];
 declare const useSearchType: () => [SearchType, import("react").Dispatch<import("react").SetStateAction<SearchType>>];
@@ -44,5 +45,5 @@ interface IMSearchProps {
     searchContext?: typeof DefaultContext;
     SearchComponent: (props: SelectSearchProps) => JSX.Element;
 }
-export declare const IMSearch: ({ children, searchContext, SearchComponent, }: IMSearchProps) => import("react").JSX.Element;
+export declare const IMSearch: ({ children, searchContext, SearchComponent, }: IMSearchProps) => JSX.Element;
 export {};

package/lib/packages/Search/index.js

@@ -53,7 +53,7 @@ const useSearch = (setIsVisible, setSearchTarget, setSearchType, setParamString,
 };
 export const IMSearch = ({ children, searchContext, SearchComponent, }) => {
     const Context = searchContext || DefaultContext;
-    const contextRef = useRef();
+    const contextRef = useRef(null);
     const lockRef = useLock();
     const [isVisible, setIsVisible] = useVisible();
     const [searchTarget, setSearchTarget] = useSearchTarget();

package/lib/packages/Search/types.d.ts

@@ -1,3 +1,4 @@
+import { FetchResponse } from 'expo/build/winter/fetch/FetchResponse';
 export interface SuccessResponse<T> {
     error: false;
     message: string;
@@ -10,7 +11,7 @@ export interface Success<T> {
 export interface Error {
     readonly type: 'error';
     readonly detail: unknown;
-    readonly response: Response;
+    readonly response: FetchResponse;
 }
 export interface Exception {
     readonly type: 'exception';

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

@@ -1,3 +1,4 @@
+import { JSX } from 'react';
 import { Context as DefaultContext } from './Context';
 export interface SessionResponse {
     error: boolean;
@@ -13,4 +14,4 @@ export interface IMSessionProps {
     children: JSX.Element;
     sessionContext?: typeof DefaultContext;
 }
-export declare const IMSession: ({ children, sessionContext }: IMSessionProps) => import("react").JSX.Element;
+export declare const IMSession: ({ children, sessionContext }: IMSessionProps) => JSX.Element;

package/lib/packages/Session/index.js

@@ -37,26 +37,33 @@ const useSessionStateRef = (renderTarget) => {
 };
 const useLogout = () => {
     const imFetch = useIMFetch({ noValidate: true });
-    return useCallback((cookie) => {
-        imFetch('/logout', {
-            headers: {
-                Cookie: cookie,
-            },
+    return useCallback(async (cookie) => {
+        const headers = cookie
+            ? { Cookie: cookie }
+            : {};
+        await imFetch('/logout', {
+            credentials: 'include',
+            headers: headers,
             method: 'GET',
         });
-    }, []);
+    }, [imFetch]);
 };
 const makeEncodeParams = (clientTypeId = 'pc') => {
     return `${`clientTypeId=${encodeURIComponent(clientTypeId)}`}`;
 };
-const useRequest = (setter, getter) => {
+const useRequest = (setter, getter, logout) => {
     const imFetch = useIMFetch();
-    const logout = useLogout();
     const request = useCallback(async (clientTypeId) => {
         try {
             const currentCookies = getter()?.cookies;
+            const cookie = currentCookies ? makeCookie(currentCookies) : null;
+            // previous session may still be active, so execute the logout process
+            await logout();
+            if (cookie)
+                await logout(cookie);
             const params = makeEncodeParams(clientTypeId);
             const response = await imFetch(`api/bearer/smacolow/session?${params}`, {
+                credentials: 'include',
                 headers: {
                     Accept: 'application/json',
                     'X-Intramart-Session': 'keep', // https://document.intra-mart.jp/library/iap/public/im_web_api_maker/im_web_api_maker_programming_guide/texts/how_to_use_api/index.html#session-management
@@ -69,8 +76,6 @@ const useRequest = (setter, getter) => {
                     const cookie = response.headers.get('Set-Cookie');
                     if (cookie) {
                         setter(cookie);
-                        if (currentCookies)
-                            logout(makeCookie(currentCookies));
                         return { status: 'success' };
                     }
                     throw new IMSessionError('could not find sessionid from Set-Cookie in response header.');
@@ -84,20 +89,18 @@ const useRequest = (setter, getter) => {
     }, [imFetch]);
     return request;
 };
-const useDestroy = (renderTarget, setter, getter) => {
-    const logout = useLogout();
-    return useCallback(() => {
+const useDestroy = (renderTarget, setter, getter, logout) => {
+    return useCallback(async () => {
         const { cookies } = getter();
         if (cookies) {
-            logout(makeCookie(cookies));
+            await logout(makeCookie(cookies));
         }
         setter(null);
         renderTarget.dispatch();
     }, []);
 };
-const useGetSessionAsync = (request, destroy, getter) => {
+const useGetSessionAsync = (request, destroy, getter, logout) => {
     const imFetch = useIMFetch({ noValidate: true });
-    const logout = useLogout();
     const reRequest = async (count) => {
         const { status } = await request();
         if (status === 'success') {
@@ -114,8 +117,10 @@ const useGetSessionAsync = (request, destroy, getter) => {
         const { cookies } = getter();
         if (cookies) {
             const response = await imFetch('api/smacolow/session', {
+                credentials: 'include',
                 headers: {
                     Cookie: makeCookie(cookies),
+                    'X-Intramart-Session': 'keep', // https://document.intra-mart.jp/library/iap/public/im_web_api_maker/im_web_api_maker_programming_guide/texts/how_to_use_api/index.html#session-management
                 },
                 method: 'GET',
             });
@@ -123,7 +128,7 @@ const useGetSessionAsync = (request, destroy, getter) => {
                 return getter();
             }
             else {
-                logout(makeCookie(cookies));
+                await logout(makeCookie(cookies));
             }
         }
         const status = await reRequest(0);
@@ -133,8 +138,7 @@ const useGetSessionAsync = (request, destroy, getter) => {
         throw new IMSessionError('failed to get session.');
     }, [request]);
 };
-const unmountEffect = (getter) => {
-    const logout = useLogout();
+const unmountEffect = (getter, logout) => {
     const { cookies } = getter();
     useEffect(() => {
         return () => {
@@ -146,13 +150,14 @@ const unmountEffect = (getter) => {
 };
 export const IMSession = ({ children, sessionContext }) => {
     const Context = sessionContext || DefaultContext;
-    const contextRef = useRef();
+    const contextRef = useRef(null);
     const sessionStateRenderTarget = useRenderTarget();
     const [, setSession, getSession] = useSessionStateRef(sessionStateRenderTarget);
-    const request = useRequest(setSession, getSession);
-    const destroy = useDestroy(sessionStateRenderTarget, setSession, getSession);
-    const getSessionAsync = useGetSessionAsync(request, destroy, getSession);
-    unmountEffect(getSession);
+    const logout = useLogout();
+    const request = useRequest(setSession, getSession, logout);
+    const destroy = useDestroy(sessionStateRenderTarget, setSession, getSession, logout);
+    const getSessionAsync = useGetSessionAsync(request, destroy, getSession, logout);
+    unmountEffect(getSession, logout);
     contextRef.current = {
         getSession,
         getSessionAsync,

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

@@ -3,6 +3,7 @@ import { IMOAuth } from '../OAuth';
 import { IMSession } from '../Session';
 import { IMSearch } from '../Search';
 import { IMTenant } from '../Tenant';
+import { JSX } from 'react';
 interface SmartlimeProps {
     children: JSX.Element;
     baseUrl: string;
@@ -16,5 +17,5 @@ interface SmartlimeProps {
     imsession?: Omit<React.ComponentProps<typeof IMSession>, 'children'>;
     imseach?: Omit<React.ComponentProps<typeof IMSearch>, 'children'>;
 }
-export declare const Smartlime: ({ children, baseUrl, tenantId, imtenant, imoauth, imme, imsession, imseach, }: SmartlimeProps) => import("react").JSX.Element;
+export declare const Smartlime: ({ children, baseUrl, tenantId, imtenant, imoauth, imme, imsession, imseach, }: SmartlimeProps) => JSX.Element;
 export {};

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

@@ -1,12 +1,20 @@
-import { FetchModuleState, Moudles } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
+import { ModuleIds } from './modulesType';
+export interface IMModule {
+    moduleId: ModuleIds[number];
+    version: string;
+    enabled: boolean;
+    others: unknown;
+}
+export type IMModules = {
+    [key in ModuleIds[number]]: IMModule;
+};
 export interface TenantContext {
     getBaseUrl: () => string;
     getTenantId: () => string | undefined;
-    getFetchModuleState: () => FetchModuleState;
-    getModuleInfo: () => Moudles | undefined;
-    destroyModuleInfo: () => Promise<void>;
-    fetchModuleInfo: () => Promise<void>;
+    getModules: () => IMModules | undefined;
+    setModules: (state: IMModules, silent?: boolean) => void;
+    destroyModule: () => Promise<void>;
     modulesStateRenderTarget: RenderTarget;
 }
 export declare const Context: import("react").Context<TenantContext | null>;

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

@@ -0,0 +1,2 @@
+export declare const IM_MODULE_STORAGE_KEY = "IM_MODULE_STORAGE_KEY";
+export declare const createStorageKey: (baseUrl: string) => string;

package/lib/packages/Tenant/constants.js

@@ -0,0 +1,4 @@
+export const IM_MODULE_STORAGE_KEY = 'IM_MODULE_STORAGE_KEY';
+export const createStorageKey = (baseUrl) => {
+    return `${baseUrl}_${IM_MODULE_STORAGE_KEY}`;
+};

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { Context as DefaultContext, IMModules } from '../Context';
+export declare const useIMModules: (Context?: typeof DefaultContext) => {
+    request: () => Promise<void>;
+    getModules: () => IMModules | undefined;
+    destroy: () => Promise<void>;
+};

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

@@ -0,0 +1,79 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useContext, useMemo } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { createStorageKey } from '../constants';
+import { Context as DefaultContext } from '../Context';
+import { IMTenantError } from '../IMTenantError';
+import { MODULE_IDS } from '../modulesType';
+const saveModuleStorage = async (storageKey, Modules) => {
+    return await AsyncStorage.setItem(storageKey, JSON.stringify(Modules));
+};
+const getModuleStorage = async (storageKey) => {
+    const state = await AsyncStorage.getItem(storageKey);
+    if (state == null)
+        return;
+    const result = JSON.parse(state);
+    return result;
+};
+const createInitialModules = () => {
+    const initState = MODULE_IDS.reduce((acc, moduleId) => {
+        acc[moduleId] = {
+            moduleId: moduleId,
+            version: '',
+            enabled: false,
+            others: {},
+        };
+        return acc;
+    }, {});
+    return initState;
+};
+const useRequestModule = (baseUrl, setModules) => {
+    const IMFetch = useIMFetch();
+    return async () => {
+        const storageKey = createStorageKey(baseUrl);
+        const storageState = await getModuleStorage(storageKey);
+        if (storageState) {
+            setModules(storageState);
+        }
+        else {
+            const response = await IMFetch('api/smacolow/modules');
+            if (response.status === 404) {
+                const state = createInitialModules();
+                saveModuleStorage(storageKey, state);
+                setModules(state);
+                return;
+            }
+            if (response.status !== 200) {
+                throw new IMTenantError('failed to fetch module status.');
+            }
+            const result = await response.json();
+            const state = result.data.modules.reduce((acc, module) => {
+                const { moduleId, moduleVersion } = module;
+                acc[moduleId] = {
+                    moduleId: moduleId,
+                    version: moduleVersion,
+                    enabled: true,
+                    others: {},
+                };
+                return acc;
+            }, createInitialModules());
+            saveModuleStorage(storageKey, state);
+            setModules(state);
+        }
+    };
+};
+export const useIMModules = (Context) => {
+    const tenantContext = useContext(Context || DefaultContext);
+    if (tenantContext == null) {
+        throw new IMTenantError('useIMModules requires either a Context provide or an ancestor element with a IMTenantProvider.');
+    }
+    const requestModule = useRequestModule(tenantContext.getBaseUrl(), tenantContext.setModules);
+    return useMemo(() => {
+        const { getModules, destroyModule } = tenantContext;
+        return {
+            request: requestModule,
+            getModules,
+            destroy: destroyModule,
+        };
+    }, [tenantContext]);
+};

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

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