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

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,24 +1,13 @@
-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>);