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

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

@@ -1,4 +1,4 @@
 import { Context as DefaultContext } from '../Context';
 export declare const useIMSearch: (Context?: typeof DefaultContext) => {
-    startSearch: ({ target, type, paramString, }: import("..").StartSearchArg) => Promise<import("..").StartSearchResult<import("..").SearchType>>;
+    startSearch: ({ target, type, paramString, }: import("..").StartSearchArg) => Promise<import("..").StartSearchResult<typeof type>>;
 };

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,9 +1,9 @@
-/// <reference types="react" />
+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>>];
@@ -45,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/Context.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import { ErrorResult, SuccessResult } from '.';
 import { RenderTarget } from '../../_shared/renderTarget';
 import setCookie from 'set-cookie-parser';

package/lib/packages/Session/hooks/useSession.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="set-cookie-parser" />
 import { Context as DefaultContext } from '../Context';
 export declare const useSession: (Context?: typeof DefaultContext) => {
     getSession: () => {

package/lib/packages/Session/hooks/useSessionState.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="set-cookie-parser" />
 import { Context as DefaultContext } from '../Context';
 export declare const useSessionState: (Context?: typeof DefaultContext) => {
     cookies: import("set-cookie-parser").Cookie[] | null;

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

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import { JSX } from 'react';
 import { Context as DefaultContext } from './Context';
 export interface SessionResponse {
     error: boolean;
@@ -14,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/NotSearchPropError.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import { SelectSearchProps } from '../Search';
 export declare const NotSearchPropError: ({ error }: SelectSearchProps) => import("react").JSX.Element;

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

@@ -1,9 +1,9 @@
-/// <reference types="react" />
 import { IMMe } from '../Me';
 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;
@@ -17,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,13 +1,20 @@
-/// <reference types="react" />
-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;

package/lib/packages/Tenant/hooks/{useIMFetchModuleState.js → useIMModulesState.js}

@@ -1,12 +1,12 @@
 import { useContext, useEffect, useReducer, useRef } from 'react';
 import { Context as DefaultContext } from '../Context';
 import { IMTenantError } from '../IMTenantError';
-export const useIMFetchModuleState = (Context) => {
+export const useIMModulesState = (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.');
+        throw new IMTenantError('useIMModulesState requires either a Context provide or an ancestor element with a IMTenantProvider.');
     }
     if (initRef.current) {
         initRef.current = false;
@@ -17,6 +17,5 @@ export const useIMFetchModuleState = (Context) => {
             tenantContext.modulesStateRenderTarget.removeEventListener(forceRender);
         };
     }, []);
-    const state = tenantContext.getFetchModuleState();
-    return state;
+    return tenantContext.getModules();
 };

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

@@ -1,25 +1,13 @@
-/// <reference types="react" />
-import { Context as DefaultContext } from './Context';
-import { ModuleIds } from './modulesType';
+import { JSX } from 'react';
+import { Context as DefaultContext, IMModules } from './Context';
 interface IMTenantProps {
     children: JSX.Element;
     baseUrl: string;
     tenantId?: string;
     tenantContext?: typeof DefaultContext;
-    useModuleInfo?: boolean;
 }
-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;
+    modules?: IMModules;
 }
-export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, useModuleInfo, }: IMTenantProps) => import("react").JSX.Element;
+export declare const IMTenant: ({ children, baseUrl, tenantId, tenantContext, }: IMTenantProps) => JSX.Element;
 export {};

package/lib/packages/Tenant/index.js

@@ -1,115 +1,48 @@
 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';
+import { createStorageKey } from './constants';
 const useGetBaseUrl = (baseUrl) => {
     return useCallback(() => baseUrl, [baseUrl]);
 };
 const useGetTenantId = (tenantId) => {
     return useCallback(() => tenantId, [tenantId]);
 };
-const createInitFetchModuleState = (useModuleInfo) => {
-    return useModuleInfo ? 'notFetched' : 'notRequired';
-};
-const createStorageKey = (baseUrl, moduleKey) => {
-    return `${baseUrl}_${moduleKey}`;
-};
-const saveModuleInfoStorage = async (storageKey, ModuleInfo) => {
-    return await AsyncStorage.setItem(storageKey, JSON.stringify(ModuleInfo));
-};
-const deleteModuleInfoStorage = async (storageKey) => {
+const deleteModuleStorage = 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 useModuleRef = (baseUrl, renderTarget) => {
+    const ref = useRef(null);
     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 = (baseUrl, 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);
-    }, [fetchModuleStateSetter, useModuleInfo]);
-    const getter = useCallback(() => ref.current, []);
+    const getter = useCallback(() => (ref.current == null ? void 0 : ref.current), []);
     const destroy = useCallback(async () => {
-        for (let i = 0; i < MODULE_IDS.length; i++) {
-            const key = MODULE_IDS[i];
-            if (key) {
-                const storageKey = createStorageKey(baseUrl, key);
-                await deleteModuleInfoStorage(storageKey);
-            }
-        }
-        ref.current = undefined;
-        fetchModuleStateSetter('notFetched');
-    }, [fetchModuleStateSetter, baseUrl]);
+        const storageKey = createStorageKey(baseUrl);
+        await deleteModuleStorage(storageKey);
+        ref.current = null;
+        renderTarget.dispatch();
+    }, [baseUrl]);
     return [ref, setter, getter, destroy];
 };
-const createCheckHybridSSOUrl = (baseUrl) => {
-    return join(baseUrl, '/im_hybrid_sso/logout');
-};
-const useFetchModuleInfo = (baseUrl, setModuleInfo) => {
-    return useCallback(async () => {
-        const hybridSSOUrl = createCheckHybridSSOUrl(baseUrl);
-        const storageKey = createStorageKey(baseUrl, 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, baseUrl]);
-};
-export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, useModuleInfo, }) => {
+export const IMTenant = ({ children, baseUrl, tenantId, tenantContext, }) => {
     const Context = tenantContext || DefaultContext;
-    const contextRef = useRef();
+    const contextRef = useRef(null);
     const modulesStateRenderTarget = useRenderTarget();
     const getBaseUrl = useGetBaseUrl(baseUrl);
     const getTenantId = useGetTenantId(tenantId);
-    const [, setFetchModuleState, getFetchModuleState] = useFetchModuleStateRef(modulesStateRenderTarget, useModuleInfo);
-    const [, setModuleInfo, getModuleInfo, destroyModuleInfo] = useModuleInfoRef(baseUrl, setFetchModuleState, useModuleInfo);
-    const fetchModuleInfo = useFetchModuleInfo(baseUrl, setModuleInfo);
+    const [, setModules, getModules, destroyModule] = useModuleRef(baseUrl, modulesStateRenderTarget);
     contextRef.current = {
         getBaseUrl,
         getTenantId,
-        getFetchModuleState,
-        getModuleInfo,
-        destroyModuleInfo,
-        fetchModuleInfo,
+        getModules,
+        setModules,
+        destroyModule,
         modulesStateRenderTarget,
     };
     return (<Context.Provider value={contextRef.current}>{children}</Context.Provider>);