@common-stack/mobile-stack-react 6.0.6-alpha.100

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2017 CDMBase LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# React Package
+React components and containers
+
+What does it include:
+---
+    1. exported react pure components
+    2. exported react containers
+    3. Typescript 2.0.0 => ES6
+    4. unit testing with jest
+
+Purpose:
+---
+This package can be installable in front-end webserver
+
+Useful commands:
+---
+    npm run build       - build the library files
+    npm run test        - run tests once
+    npm run test:watch  - run tests in watchmode (Useful for development)
+    
+Files explained:
+---
+     src                         - directory is used for typescript code that is part of the project
+        index.ts                 - Index file of the package. Consists of exported components and containers
+        index.spec.ts            - Tests file for main
+        components               - All pure components which don't depend on backend data or external state such as redux
+            index.ts             - References all the exported components
+        containers               - Components with data to render. Tightly coupled with redux. 
+            index.ts             - References all the exported containers
+     package.json                - file is used to describe the library and packages that are required added under peer-dependencies section
+     tsconfig.json               - configuration file for the library compilation
+     webpack.config.js           - configuration file of the compilation automation process for the library
+
+
+Tutorials:
+---
+[react-jest-enzymes test](https://www.youtube.com/watch?v=bMmntkVM4wQ)
+
+[testing react with enzyme tutorial](http://codeheaven.io/testing-react-components-with-enzyme/)
+
+[react-redux-typescript-guide](https://github.com/piotrwitek/react-redux-typescript-guide)
+
+Performance:
+---
+[Redux FAQ: Connecting multiple components](http://redux.js.org/docs/FAQ.html#react-multiple-components)
+
+[React/Redux Links: Performance articles](https://github.com/markerikson/react-redux-links/blob/master/react-performance.md)
+
+[React/Redux: Component re-rendering too often?](http://redux.js.org/docs/faq/ReactRedux.html#react-rendering-too-often)
+                 

package/lib/config/base-apollo-cache.d.ts

@@ -0,0 +1,16 @@
+import { InMemoryCache } from '@apollo/client/cache/index.js';
+import { CdmLogger } from '@cdm-logger/core';
+interface CreateCacheParams {
+    getDataIdFromObject: (x?: any) => string;
+    clientState: any;
+    initialState?: any;
+    logger: CdmLogger.ILogger;
+}
+export declare const createCache: ({ getDataIdFromObject, clientState }: CreateCacheParams) => InMemoryCache;
+export declare const initializeCache: ({ cache, initialState, clientState, logger, }: {
+    cache: InMemoryCache;
+    initialState?: any;
+    clientState: any;
+    logger: CdmLogger.ILogger;
+}) => void;
+export {};

package/lib/config/base-apollo-cache.js

@@ -0,0 +1,35 @@
+import {InMemoryCache}from'@apollo/client/cache/index.js';// cache.ts
+const createCache = ({ getDataIdFromObject, clientState }) => {
+    const cache = new InMemoryCache({
+        dataIdFromObject: getDataIdFromObject,
+        possibleTypes: clientState.possibleTypes,
+        typePolicies: clientState.typePolicies,
+    });
+    return cache;
+};
+const initializeCache = ({ cache, initialState, clientState, logger, }) => {
+    if (initialState) {
+        try {
+            cache.restore(initialState);
+            logger.debug('Cache restored with initial state');
+        }
+        catch (err) {
+            logger.error(err, 'Error restoring cache');
+        }
+    }
+    else {
+        clientState.defaults?.forEach((x) => {
+            try {
+                if (x.type === 'query') {
+                    cache.writeQuery({ query: x.query, data: x.data });
+                }
+                else if (x.type === 'fragment') {
+                    cache.writeFragment({ id: x.id, fragment: x.fragment, data: x.data });
+                }
+            }
+            catch (err) {
+                logger.error(err, 'Error writing to cache');
+            }
+        });
+    }
+};export{createCache,initializeCache};

package/lib/config/base-apollo-client.d.ts

@@ -0,0 +1,19 @@
+import { ApolloClient, NormalizedCacheObject, InMemoryCache } from '@apollo/client/index.js';
+import { CdmLogger } from '@cdm-logger/core';
+interface IApolloClientParams {
+    initialState?: any;
+    scope: 'browser' | 'server' | 'native';
+    getDataIdFromObject: (x?: any) => string;
+    clientState: any;
+    isDebug: boolean;
+    isDev: boolean;
+    isSSR: boolean;
+    httpGraphqlURL: string;
+    httpLocalGraphqlURL: string;
+    logger: CdmLogger.ILogger;
+}
+export declare const createApolloClient: ({ scope, isDev, isDebug, isSSR, getDataIdFromObject, clientState, httpGraphqlURL, httpLocalGraphqlURL, initialState, logger, }: IApolloClientParams) => {
+    apolloClient: ApolloClient<NormalizedCacheObject>;
+    cache: InMemoryCache;
+};
+export {};

package/lib/config/base-apollo-client.js

@@ -0,0 +1,119 @@
+import {isBoolean,merge}from'lodash-es';import {ApolloLink,ApolloClient}from'@apollo/client/index.js';import {HttpLink}from'@apollo/client/link/http/index.js';import {BatchHttpLink}from'@apollo/client/link/batch-http/index.js';import {onError}from'@apollo/client/link/error/index.js';import {GraphQLWsLink}from'@apollo/client/link/subscriptions/index.js';import {getOperationAST}from'graphql';import {invariant}from'ts-invariant';import {RetryLink}from'@apollo/client/link/retry/index.js';import {createClient}from'graphql-ws';import fetch from'cross-fetch';import {createCache,initializeCache}from'./base-apollo-cache.js';// apolloClient.ts
+const schema = `
+  # Add your schema here
+`;
+const errorLink = onError(({ graphQLErrors, networkError }) => {
+    if (graphQLErrors) {
+        graphQLErrors.map(({ message, locations, path }) => invariant.warn(`[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}`));
+    }
+    if (networkError) {
+        invariant.warn(`[Network error]: ${networkError}`);
+    }
+});
+const createApolloClient = ({ scope, isDev, isDebug, isSSR, getDataIdFromObject, clientState, httpGraphqlURL, httpLocalGraphqlURL, initialState, logger, }) => {
+    logger.debug('Initializing Apollo Client with parameters, {%o}', {
+        scope,
+        isDev,
+        isDebug,
+        isSSR,
+        httpGraphqlURL,
+        httpLocalGraphqlURL,
+    });
+    const isBrowser = scope === 'browser';
+    const isServer = scope === 'server';
+    const cache = createCache({ getDataIdFromObject, clientState, logger });
+    logger.debug('Created new Apollo memory cache');
+    const retryLink = new RetryLink({
+        attempts: async (count, operation, error) => {
+            logger.debug('Retrying link attempt', { count, operation, error });
+            const promises = (clientState.retryLinkAttemptFuncs || []).map((func) => func(count, operation, error));
+            try {
+                const result = await Promise.all(promises);
+                return !!result.find((item) => item && isBoolean(item));
+            }
+            catch (e) {
+                logger.error(e, 'Error occurred in retryLink attempt condition');
+                throw e;
+            }
+        },
+    });
+    let link;
+    if (isBrowser) {
+        const connectionParams = async () => {
+            logger.debug('Getting WebSocket connection parameters');
+            const param = {};
+            for (const connectionParam of clientState.connectionParams) {
+                const result = await connectionParam();
+                merge(param, await result());
+            }
+            return param;
+        };
+        const wsLink = new GraphQLWsLink(createClient({
+            url: httpGraphqlURL.replace(/^http/, 'ws'),
+            retryAttempts: 10,
+            lazy: true,
+            shouldRetry: () => true,
+            keepAlive: 10000,
+            connectionParams,
+            on: {
+                connected: (socket) => logger.debug('WebSocket connected'),
+                error: async (error) => {
+                    logger.error(error, 'WebSocket connection error');
+                    const promises = (clientState.connectionCallbackFuncs || []).map((func) => func(wsLink, error, {}));
+                    try {
+                        await Promise.all(promises);
+                    }
+                    catch (err) {
+                        logger.trace('Error occurred in WebSocket connection callback', err);
+                        throw err;
+                    }
+                },
+                ping: () => logger.trace('Ping server'),
+                pong: () => logger.trace('Pong received'),
+            },
+        }));
+        link = ApolloLink.split(({ query, operationName }) => {
+            if (operationName.endsWith('_WS')) {
+                return true;
+            }
+            const operationAST = getOperationAST(query, operationName);
+            return !!operationAST && operationAST.operation === 'subscription';
+        }, wsLink, new HttpLink({ uri: httpGraphqlURL, credentials: 'include', fetch }));
+    }
+    else if (isServer) {
+        logger.debug('Creating BatchHttpLink for server');
+        link = new BatchHttpLink({
+            uri: httpLocalGraphqlURL,
+            fetch,
+            batchInterval: 200,
+            batchMax: 100,
+            credentials: 'include',
+        });
+    }
+    else {
+        logger.debug('Creating HttpLink for native');
+        link = new HttpLink({ uri: httpLocalGraphqlURL, fetch, credentials: 'include' });
+    }
+    const links = [errorLink, retryLink, ...(clientState.preLinks || []), link].filter(Boolean);
+    const params = {
+        queryDeduplication: true,
+        typeDefs: schema.concat(clientState.typeDefs || ''),
+        resolvers: clientState.resolvers,
+        link: ApolloLink.from(links),
+        cache,
+        credentials: 'include',
+        connectToDevTools: isBrowser && (isDev || isDebug),
+    };
+    if (isSSR) {
+        if (isBrowser) {
+            params.ssrForceFetchDelay = 100;
+        }
+        else if (isServer) {
+            params.ssrMode = true;
+        }
+    }
+    const apolloClient = new ApolloClient(params);
+    logger.debug('Created new Apollo client');
+    initializeCache({ cache, initialState, clientState, logger });
+    return { apolloClient, cache };
+};export{createApolloClient};

package/lib/config/base-redux-config.d.ts

@@ -0,0 +1,24 @@
+import { Middleware, StoreEnhancer } from 'redux';
+import { EpicMiddleware, Epic } from 'redux-observable';
+import { PersistConfig } from 'redux-persist';
+interface IReduxStore<S = any> {
+    scope: 'browser' | 'server' | 'native' | 'ElectronMain';
+    isDebug: boolean;
+    isDev: boolean;
+    reducers: any;
+    enhancers?: StoreEnhancer[];
+    rootEpic: Epic<any, any, any, any>;
+    epicMiddleware?: EpicMiddleware<any, any, S, any>;
+    preMiddleware?: Middleware[];
+    postMiddleware?: Middleware[];
+    middleware?: Middleware[];
+    initialState?: any;
+    persistConfig?: PersistConfig<any>;
+    reduxConfig?: any;
+}
+/**
+ * Add any reducers required for this app dirctly in to
+ * `combineReducers`
+ */
+export declare const createReduxStore: ({ scope, isDebug, isDev, reducers, rootEpic, enhancers, epicMiddleware, preMiddleware, postMiddleware, middleware, initialState, persistConfig, reduxConfig, }: IReduxStore<any>) => import("redux").Store<any, import("redux").UnknownAction, unknown>;
+export {};

package/lib/config/base-redux-config.js

@@ -0,0 +1,39 @@
+import {combineReducers,configureStore}from'@reduxjs/toolkit';import {persistReducer}from'redux-persist';// version 11/12/2021
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable global-require */
+/* eslint-disable no-underscore-dangle */
+/**
+ * Add any reducers required for this app dirctly in to
+ * `combineReducers`
+ */
+const createReduxStore = ({ scope, isDebug, isDev, reducers, rootEpic, enhancers = [], epicMiddleware, preMiddleware = [], postMiddleware = [], middleware = [], initialState, persistConfig, reduxConfig, }) => {
+    const isBrowser = scope === 'browser';
+    const isElectronMain = scope === 'ElectronMain';
+    const rootReducer = combineReducers(reducers);
+    const persistedReducer = persistConfig && isBrowser ? persistReducer(persistConfig, rootReducer) : rootReducer;
+    /**
+     * Add middleware that required for this app.
+     */
+    // Add redux logger during development only
+    const middlewares = [
+        ...preMiddleware,
+        ...(epicMiddleware ? [epicMiddleware] : []),
+        ...middleware,
+        ...postMiddleware,
+    ];
+    const store = configureStore({
+        reducer: persistedReducer,
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+            serializableCheck: false,
+        }).concat(...middlewares),
+        devTools: isDev || isDebug,
+        preloadedState: initialState,
+        enhancers: (getDefaultEnhancers) => getDefaultEnhancers().concat(...enhancers),
+    });
+    if ((isBrowser || isElectronMain) && epicMiddleware && rootEpic) {
+        epicMiddleware.run(rootEpic);
+    }
+    return store;
+};export{createReduxStore};

package/lib/config/client.service.d.ts

@@ -0,0 +1,9 @@
+import 'reflect-metadata';
+import { Container } from 'inversify';
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client/index.js';
+export declare const createClientContainer: (req?: any, res?: any) => {
+    container: Container;
+    apolloClient: ApolloClient<NormalizedCacheObject>;
+    serviceFunc: () => any;
+    logger: import("@cdm-logger/core/lib/interface").ILogger;
+};

package/lib/config/client.service.js

@@ -0,0 +1,71 @@
+import'reflect-metadata';import {ClientTypes}from'@common-stack/client-core';import {ScopedContainer}from'@common-stack/client-core/lib/connector/ScopedContainer.js';import {merge}from'lodash-es';import features from'../modules.js';import {logger,UtilityClass}from'../utils/index.js';import {createApolloClient}from'./base-apollo-client.js';import {config}from'./mobile-env-config.js';const utility = new UtilityClass(features);
+ScopedContainer.registerGlobalDependencies((container) => {
+    container.bind(ClientTypes.Logger).toConstantValue(logger);
+    container.bind(ClientTypes.UtilityClass).toConstantValue(utility);
+});
+const createClientContainer = (req, res) => {
+    logger.debug('Calling CreateClientContainer');
+    // const childContainer = container.createChild();
+    const container = features.createContainers({});
+    container
+        .bind(ClientTypes.ApolloClient)
+        .toDynamicValue((context) => new Error('Too early to bind ApolloClient'))
+        .inRequestScope();
+    container
+        .bind(ClientTypes.ApolloClientFactory)
+        .toDynamicValue((context) => () => {
+        const newClient = container.get(ClientTypes.ApolloClient);
+        return newClient;
+    });
+    const services = merge({ container }, ...features.createServiceFunc.map((serviceFunc) => serviceFunc(container)));
+    const clientState = features.getStateParams({
+        resolverContex: () => services,
+        // container: container,
+        requestResponsePair: {
+            req,
+            res,
+        },
+    });
+    const { apolloClient, cache } = createApolloClient({
+        httpGraphqlURL: config.GRAPHQL_URL,
+        httpLocalGraphqlURL: config.LOCAL_GRAPHQL_URL,
+        isDev: process.env.NODE_ENV === 'development',
+        isDebug: false,
+        isSSR: true,
+        scope: typeof window !== 'undefined' ? 'browser' : 'server',
+        clientState,
+        getDataIdFromObject: (result) => features.getDataIdFromObject(result),
+        initialState: undefined,
+        logger,
+    });
+    if (!container.isBound(ClientTypes.InMemoryCache)) {
+        container
+            .bind(ClientTypes.InMemoryCache)
+            .toDynamicValue((context) => cache)
+            .inRequestScope();
+    }
+    container
+        .rebind(ClientTypes.ApolloClient)
+        .toDynamicValue((context) => apolloClient)
+        .inRequestScope();
+    // const services = serviceFunc();
+    const serviceFunc = () => services;
+    apolloClient.container = services;
+    const clientService = {
+        container,
+        apolloClient,
+        serviceFunc,
+        logger,
+    };
+    if (module.hot) {
+        module.hot.dispose(() => {
+            // Force Apollo to fetch the latest data from the server
+            delete window.__APOLLO_STATE__;
+        });
+    }
+    if (typeof window !== 'undefined') {
+        //@ts-ignore
+        window.__CLIENT_SERVICE__ = clientService;
+    }
+    return clientService;
+};export{createClientContainer};

package/lib/config/env-config.d.ts

@@ -0,0 +1,15 @@
+export declare const config: Readonly<{
+    CLIENT_URL: string;
+    LAYOUT_SETTINGS: {
+        navTheme: string;
+        primaryColor: string;
+        layout: string;
+        contentWidth: string;
+        fixedHeader: boolean;
+        fixSiderbar: boolean;
+        colorWeak: boolean;
+        title: string;
+        iconfontUrl: string;
+        language: string;
+    };
+} & import("envalid").CleanedEnvAccessors>;

package/lib/config/epic-config.d.ts

@@ -0,0 +1,3 @@
+import { BehaviorSubject } from 'rxjs';
+export declare const epic$: BehaviorSubject<import("redux-observable").Epic<unknown, unknown, void, any>>;
+export declare const rootEpic: (action$: any, state$: any, dependencies: any) => import("rxjs").Observable<unknown>;

package/lib/config/epic-config.js

@@ -0,0 +1,6 @@
+import {combineEpics,ofType}from'redux-observable';import {BehaviorSubject,mergeMap,takeUntil}from'rxjs';import features from'../modules.js';const epic$ = new BehaviorSubject(combineEpics(...features.epics));
+// Since we're using mergeMap, by default any new
+// epic that comes in will be merged into the previous
+// one, unless an EPIC_END action is dispatched first,
+// which would cause the old one(s) to be unsubscribed
+const rootEpic = (action$, state$, dependencies) => epic$.pipe(mergeMap((epic) => epic(action$, state$, dependencies).pipe(takeUntil(action$.pipe(ofType('EPIC_END'))))));export{epic$,rootEpic};

package/lib/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client.service';
+export * from './redux-config';

package/lib/config/mobile-env-config.d.ts

@@ -0,0 +1,7 @@
+export declare const config: Readonly<{
+    GA_ID: string;
+    GRAPHQL_URL: string;
+    LOCAL_GRAPHQL_URL: string;
+    GRAPHQL_SUBSCRIPTION_URL: string;
+    LOG_LEVEL: string;
+} & import("envalid").CleanedEnvAccessors>;

package/lib/config/mobile-env-config.js

@@ -0,0 +1,8 @@
+import {cleanEnv,str}from'envalid';import {getEnvironment}from'@common-stack/core';const env = getEnvironment();
+const config = cleanEnv(env, {
+    GA_ID: str({ devDefault: 'G-xxxxxxx' }),
+    GRAPHQL_URL: str({ default: env?.GRAPHQL_URL }),
+    LOCAL_GRAPHQL_URL: str({ default: env?.GRAPHQL_URL }),
+    GRAPHQL_SUBSCRIPTION_URL: str({ default: env?.GRAPHQL_URL?.replace(/^http/, 'ws') }),
+    LOG_LEVEL: str({ devDefault: 'debug' }),
+});export{config};

package/lib/config/redux-config.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import { EpicMiddleware } from 'redux-observable';
+import { PersistConfig } from 'redux-persist';
+import modules from '../modules';
+import history from './router-history';
+import { logger } from '../utils';
+export { history };
+interface Dependencies {
+    apolloClient: any;
+    routes: ReturnType<typeof modules.getConfiguredRoutes>;
+    services: any;
+    container: any;
+    logger: typeof logger;
+    config?: any;
+}
+export declare const epicMiddlewareFunc: (apolloClient: any, services: any, container: any) => EpicMiddleware<any, any, any, Dependencies>;
+export declare const persistConfig: PersistConfig<any>;
+export declare const createReduxStore: (apolloClient: any, services: any, container: any) => {
+    store: any;
+};

package/lib/config/redux-config.js

@@ -0,0 +1,52 @@
+import'reflect-metadata';import storage from'@react-native-async-storage/async-storage';import autoMergeLevel2 from'redux-persist/lib/stateReconciler/autoMergeLevel2';import {createEpicMiddleware}from'redux-observable';import {REDUX_PERSIST_KEY,ClientTypes}from'@common-stack/client-core';import {createReduxStore as createReduxStore$1}from'./base-redux-config.js';import features from'../modules.js';import {rootEpic}from'./epic-config.js';export{default as history}from'./router-history.js';import {logger}from'../utils/index.js';const epicMiddlewareFunc = (apolloClient, services, container) => createEpicMiddleware({
+    dependencies: {
+        apolloClient,
+        routes: features.getConfiguredRoutes(),
+        services,
+        container,
+        logger,
+        config: {
+            loadRoot: true,
+            isMobile: true,
+        },
+    },
+});
+const persistConfig = {
+    key: REDUX_PERSIST_KEY,
+    storage,
+    stateReconciler: autoMergeLevel2,
+    transforms: features.reduxPersistStateTransformers,
+};
+const createReduxStore = (apolloClient, services, container) => {
+    let store;
+    let initialState = {};
+    let middlewares = [];
+    store = createReduxStore$1({
+        scope: typeof window !== 'undefined' ? 'browser' : 'server',
+        isDebug: true,
+        isDev: process.env.NODE_ENV === 'development',
+        initialState,
+        persistConfig,
+        middleware: middlewares,
+        epicMiddleware: epicMiddlewareFunc(apolloClient, services, container),
+        rootEpic: rootEpic,
+        reducers: { ...features.reducers },
+        reduxConfig: features.getReduxConfig(),
+    });
+    logger.debug('Created new Redux store');
+    if (container.isBound(ClientTypes.ReduxStore)) {
+        container
+            .rebind(ClientTypes.ReduxStore)
+            .toDynamicValue(() => store)
+            .inRequestScope();
+        logger.debug('Rebound ReduxStore in container');
+    }
+    else {
+        container
+            .bind(ClientTypes.ReduxStore)
+            .toDynamicValue(() => store)
+            .inRequestScope();
+        logger.debug('Bound ReduxStore in container');
+    }
+    return { store };
+};export{createReduxStore,epicMiddlewareFunc,persistConfig};

package/lib/config/router-history.d.ts

@@ -0,0 +1,2 @@
+declare const hist: import("history").MemoryHistory;
+export default hist;

package/lib/config/router-history.js

@@ -0,0 +1 @@
+import {createMemoryHistory}from'history';const hist = createMemoryHistory();export{hist as default};

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './utils';
+export * from './load-context.mobile';

package/lib/index.js

@@ -0,0 +1 @@
+export{createClientContainer}from'./config/client.service.js';export{createReduxStore,epicMiddlewareFunc,persistConfig}from'./config/redux-config.js';export{UtilityClass,logger}from'./utils/index.js';export{loadContext}from'./load-context.mobile.js';export{default as history}from'./config/router-history.js';

package/lib/load-context.mobile.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+export declare const loadContext: () => {
+    modules: import("packages/common-client-react/lib").Feature;
+    store: any;
+    container: import("inversify").Container;
+    apolloClient: import("@apollo/client").ApolloClient<import("@apollo/client").NormalizedCacheObject>;
+    persistor: import("redux-persist").Persistor;
+};

package/lib/load-context.mobile.js

@@ -0,0 +1,14 @@
+import'reflect-metadata';import {persistStore}from'redux-persist';import features from'./modules.js';import {createReduxStore}from'./config/redux-config.js';import {createClientContainer}from'./config/client.service.js';/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const loadContext = () => {
+    const { apolloClient: client, container, serviceFunc } = createClientContainer();
+    const { store } = createReduxStore(client, serviceFunc(), container);
+    const persistor = persistStore(store);
+    return {
+        modules: features,
+        store,
+        container,
+        apolloClient: client,
+        persistor,
+    };
+};export{loadContext};

package/lib/modules.d.ts

@@ -0,0 +1,3 @@
+import { Feature } from '@common-stack/client-react';
+declare const features: Feature;
+export default features;

package/lib/modules.js

@@ -0,0 +1,2 @@
+import {Feature}from'@common-stack/client-react';// This is  a sample `module.ts` that will be replaced during run time.
+const features = new Feature({});export{features as default};

package/lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+import modules from '../modules';
+export declare class UtilityClass {
+    private modules;
+    constructor(modules: any);
+    getCacheKey(storeObj: any): any;
+    navigate(name: string, params: never): void;
+}
+declare const logger: import("@cdm-logger/core/lib/interface").ILogger;
+export default modules;
+export { logger };

package/lib/utils/index.js

@@ -0,0 +1,19 @@
+import {ClientLogger}from'@cdm-logger/client';export{default}from'../modules.js';import {navigate}from'./navigator.js';/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable import/no-cycle */
+/* eslint-disable @typescript-eslint/no-var-requires */
+class UtilityClass {
+    modules;
+    // tslint:disable-next-line:no-shadowed-variable
+    constructor(modules) {
+        this.modules = modules;
+    }
+    getCacheKey(storeObj) {
+        return this.modules.getDataIdFromObject(storeObj);
+    }
+    navigate(name, params) {
+        return navigate(name, params);
+    }
+}
+const logger = ClientLogger.create(process.env.APP_NAME || 'Fullstack-Pro', {
+    level: process.env.LOG_LEVEL || 'info',
+});export{UtilityClass,logger};

package/lib/utils/navigator.d.ts

@@ -0,0 +1 @@
+export declare function navigate(name: string, params: never): void;

package/lib/utils/navigator.js

@@ -0,0 +1,5 @@
+import {navigationRef}from'@common-stack/client-react';function navigate(name, params) {
+    if (navigationRef.isReady()) {
+        navigationRef.navigate(name, params);
+    }
+}export{navigate};

package/package.json

@@ -0,0 +1,154 @@
+{
+    "name": "@common-stack/mobile-stack-react",
+    "version": "6.0.6-alpha.100",
+    "description": "Client Module for mobile app",
+    "homepage": "https://github.com/cdmbase/fullstack-pro#readme",
+    "bugs": {
+        "url": "https://github.com/cdmbase/fullstack-pro/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/cdmbase/fullstack-pro.git"
+    },
+    "license": "ISC",
+    "author": "CDMBase LLC",
+    "type": "module",
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "typings": "lib/index.d.ts",
+    "scripts": {
+        "build": "npm run build:clean && npm run build:lib",
+        "build:clean": "rimraf lib",
+        "build:lib": "rollup -c rollup.config.mjs",
+        "build:lib:watch": "npm run build:lib -- --watch",
+        "jest": "./node_modules/.bin/jest",
+        "prepublish": "npm run build",
+        "test": "jest",
+        "test:debug": "npm test -- --runInBand",
+        "test:watch": "npm test -- --watch",
+        "watch": "npm run build:lib:watch"
+    },
+    "dependencies": {
+        "@apollo/client": "^3.9.0",
+        "@cdm-logger/client": "^9.0.3",
+        "@common-stack/client-core": "6.0.6-alpha.91",
+        "@common-stack/client-react": "6.0.6-alpha.91",
+        "@common-stack/components-pro": "6.0.6-alpha.91",
+        "@common-stack/core": "6.0.6-alpha.91",
+        "@expo/vector-icons": "^14.0.2",
+        "@react-native-async-storage/async-storage": "~1.23.1",
+        "@react-native-community/datetimepicker": "8.2.0",
+        "@react-native-community/masked-view": "~0.1.10",
+        "@react-native-community/segmented-control": "~2.2.2",
+        "@react-navigation/bottom-tabs": "^7.0.0",
+        "@react-navigation/drawer": "^7.0.0",
+        "@react-navigation/native": "^7.0.0",
+        "@react-navigation/native-stack": "^7.0.0",
+        "@react-navigation/stack": "~6.3.18",
+        "@reduxjs/toolkit": "^2.2.6",
+        "apollo-link-debounce": "^3.0.0",
+        "apollo-link-logger": "^2.0.0",
+        "apollo-server-errors": "^3.3.1",
+        "big-integer": "^1.6.51",
+        "cross-fetch": "^4.0.0",
+        "envalid": "~7.2.2",
+        "expo": "~52.0.17",
+        "expo-apple-authentication": "~7.1.2",
+        "expo-auth-session": "^6.0.0",
+        "expo-blur": "~14.0.1",
+        "expo-build-properties": "~0.13.1",
+        "expo-constants": "~17.0.3",
+        "expo-dev-client": "~5.0.5",
+        "expo-device": "~7.0.1",
+        "expo-font": "~13.0.1",
+        "expo-haptics": "~14.0.0",
+        "expo-image-picker": "~16.0.3",
+        "expo-linking": "~7.0.3",
+        "expo-localization": "~16.0.0",
+        "expo-notifications": "~0.29.11",
+        "expo-random": "~14.0.1",
+        "expo-router": "~4.0.11",
+        "expo-secure-store": "~14.0.0",
+        "expo-splash-screen": "~0.29.15",
+        "expo-status-bar": "~2.0.0",
+        "expo-symbols": "~0.2.0",
+        "expo-system-ui": "~4.0.5",
+        "expo-updates": "^0.26.9",
+        "expo-web-browser": "~14.0.1",
+        "graphql": "^16.0.0",
+        "graphql-ws": "^5.11.2",
+        "history": "^4.10.1",
+        "immutability-helper": "^3.0.1",
+        "inversify": "~6.0.2",
+        "isomorphic-fetch": "^2.2.1",
+        "lodash": "^4.17.15",
+        "metro-minify-terser": "^0.56.0",
+        "minilog": "^3.1.0",
+        "prop-types": "^15.8.1",
+        "query-string": "^9.0.0",
+        "ramda": "^0.26.1",
+        "react": "18.3.1",
+        "react-dom": "18.3.1",
+        "react-helmet": "^6.1.0",
+        "react-native": "~0.76.3",
+        "react-native-confirmation-code-field": "7.3.1",
+        "react-native-dotenv": "^3.3.1",
+        "react-native-gesture-handler": "~2.20.2",
+        "react-native-get-random-values": "~1.11.0",
+        "react-native-keyboard-aware-scroll-view": "^0.9.3",
+        "react-native-keyboard-spacer": "^0.4.1",
+        "react-native-maps": "1.18.0",
+        "react-native-mime-types": "^2.3.0",
+        "react-native-modal": "^11.6.1",
+        "react-native-pager-view": "6.5.1",
+        "react-native-reanimated": "~3.16.1",
+        "react-native-safe-area-context": "4.12.0",
+        "react-native-screens": "~4.1.0",
+        "react-native-svg": "15.8.0",
+        "react-native-tab-view": "^3.5.2",
+        "react-native-tags": "2.2.1",
+        "react-native-url-polyfill": "^2.0.0",
+        "react-native-web": "~0.19.13",
+        "react-native-web-maps": "~0.3.0",
+        "react-native-webview": "13.12.5",
+        "react-redux": "^9.1.1",
+        "redux-logger": "^3.0.6",
+        "redux-observable": "^3.0.0-rc.2",
+        "redux-persist": "^6.0.0",
+        "redux-thunk": "^2.3.0",
+        "reflect-metadata": "^0.1.13",
+        "reselect": "^4.0.0",
+        "rxjs": "^7.8.1",
+        "sentry-expo": "~7.0.0",
+        "subscriptions-transport-ws": "0.9.18",
+        "text-encoding-polyfill": "^0.6.7",
+        "ts-invariant": "^0.10.3"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.25.2",
+        "@types/jest": "^29.5.12",
+        "@types/react": "~18.3.12",
+        "@types/react-dom": "~18.3.1",
+        "@types/react-test-renderer": "^18.3.0",
+        "jest": "^29.2.1",
+        "jest-expo": "~52.0.2",
+        "react-test-renderer": "18.3.1",
+        "typescript": "^5.3.3"
+    },
+    "jest": {
+        "preset": "jest-expo"
+    },
+    "peerDependencies": {
+        "@apollo/client": ">=3.0.0",
+        "react": ">=18",
+        "react-dom": ">=18",
+        "redux": ">=5.0.1"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "typescript": {
+        "definition": "lib/index.d.ts"
+    },
+    "gitHead": "d93a9fecbb65a8da04bf701b18fbb646afc403b1"
+}