@m4l/core 0.0.21 → 0.0.24

package/src/hooks/index.ts

@@ -0,0 +1,7 @@
+export { useLocalStorage } from './useLocalStorage';
+export { useHostTools } from './useHostTools';
+export { useNetwork } from './useNetwork';
+export { useEnvironment } from './useEnvironment';
+export { useFlags, useFlagsPresent } from './useFlags';
+
+export { useModuleDictionary } from './useModuleDictionary';

package/src/hooks/useEnvironment/index.test.tsx

@@ -0,0 +1,36 @@
+//import { render, screen } from '../../../test/utils';
+import { render, screen } from '../../test/utils';
+import { it } from 'vitest';
+import { EnvironmentProvider } from '../../contexts/EnvironmentContext';
+import useEnvironment from '.';
+
+it('useEnvironment tenga acceso a las variables del contexto', () => {
+    const obValue = {
+        isLocalhost: true,
+        host: 'h1',
+        domain_token: '1',
+        host_api_local: '2',
+        host_api_remote: '3',
+        host_static_assets: '4',
+        environment: '5',
+    };
+
+    const stringValue = JSON.stringify(obValue);
+
+    const Component = () => {
+        const value = useEnvironment();
+        return <div data-testid="useDivHostId">{JSON.stringify(value)}</div>;
+    };
+
+    // const { container } =
+    render(
+        <EnvironmentProvider {...obValue}>
+            <Component />
+        </EnvironmentProvider>,
+    );
+
+    // container.querySelector('#useDivHostId');
+    //console.log('Q trajo', window);
+
+    expect(screen.getByTestId('useDivHostId').textContent).toBe(stringValue);
+});

package/src/hooks/useEnvironment/index.ts

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { EnvironmentContext } from '../../contexts/EnvironmentContext';
+
+// ----------------------------------------------------------------------
+export const useEnvironment = () => {
+    const context = useContext(EnvironmentContext);
+
+    if (!context) throw new Error('useEnvironment context must be use inside EnvironmentContext');
+
+    return context;
+};
+
+export default useEnvironment;

package/src/hooks/useFlags/index.ts

@@ -0,0 +1,33 @@
+import { useContext, useEffect, useState } from 'react';
+import { FlagsContext } from '../../contexts/FlagsContext';
+import type { Flag, FlagsContextProps } from '../../contexts/FlagsContext/types';
+
+// ----------------------------------------------------------------------
+export const useFlags = (): FlagsContextProps => {
+    const context = useContext(FlagsContext);
+
+    if (!context) throw new Error('useFlags context must be use inside FlagsProvider');
+
+    return context;
+};
+
+function isFlagsPresent(compareFlags: Array<Flag>, flags: Array<Flag>) {
+    const filterFlags = compareFlags.filter(
+        findFlag => flags.findIndex(sFlag => sFlag === findFlag) !== -1,
+    );
+
+    return filterFlags.length === compareFlags.length;
+}
+export const useFlagsPresent = (compareFlags: Array<Flag>): boolean => {
+    const context = useFlags();
+
+    const [isPresent, setIsPresent] = useState(isFlagsPresent(compareFlags, context.flags));
+
+    useEffect(() => {
+        if (isFlagsPresent(compareFlags, context.flags)) {
+            setIsPresent(true);
+        }
+    }, [context.flags, compareFlags]);
+
+    return isPresent;
+};

package/src/hooks/useHostTools/index.ts

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { HostToolsContext } from '../../contexts/HostToolsContext';
+
+// ----------------------------------------------------------------------
+export const useHostTools = () => {
+    const context = useContext(HostToolsContext);
+
+    if (!context) throw new Error('useHostTools context must be use inside HostToolsContext');
+
+    return context;
+};
+
+export default useHostTools;

package/src/hooks/useLocalStorage/index.ts

@@ -0,0 +1,23 @@
+import { useState } from 'react';
+
+export function useLocalStorage<ValueType>(key: string, initialValue: ValueType) {
+    const [value, setValue] = useState(() => {
+        try {
+            const item = window.localStorage.getItem(key);
+            return item !== null ? JSON.parse(item) : initialValue;
+        } catch (e) {
+            return initialValue;
+        }
+    });
+
+    const setValueInLocalStorage = (newValue: ValueType) => {
+        try {
+            window.localStorage.setItem(key, JSON.stringify(newValue));
+            setValue(newValue);
+        } catch (e) {
+            console.error(e);
+        }
+    };
+
+    return [value, setValueInLocalStorage];
+}

package/src/hooks/useModuleDictionary/index.ts

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { ModuleDictionaryContext } from '../../contexts/ModuleDictionaryContext';
+
+// ----------------------------------------------------------------------
+export const useModuleDictionary = () => {
+    const context = useContext(ModuleDictionaryContext);
+    if (!context)
+        throw new Error('useModuleDictionary context must be use inside ModuleDictionaryProvider');
+
+    return context;
+};

package/src/hooks/useNetwork/index.ts

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { NetworkContext } from '../../contexts/NetworkContext';
+
+// ----------------------------------------------------------------------
+export const useNetwork = () => {
+    const context = useContext(NetworkContext);
+
+    if (!context) throw new Error('useNetwork context must be use inside NetworkContext');
+
+    return context;
+};
+
+export default useNetwork;

package/src/index.ts

@@ -0,0 +1,43 @@
+// //context
+export * from './contexts';
+
+//hooks
+//export * from './hooks';
+
+export { useEnvironment } from './hooks/useEnvironment';
+export { useFlags } from './hooks/useFlags';
+export { useHostTools } from './hooks/useHostTools';
+export { useLocalStorage } from './hooks/useLocalStorage';
+export { useNetwork } from './hooks/useNetwork';
+
+//enums
+export { EmitEvents } from './types';
+
+//types
+
+export type {
+    Maybe,
+    HostToolsType,
+    NetworkProps,
+    EnvironmentType,
+    AxiosOperation,
+    EventFunListener,
+} from './types';
+
+export type {
+    GetLabelType,
+    Dictionary,
+    ModuleDictionary,
+    ComponentDictionary,
+} from './types/dictionary';
+
+// //utils
+export * from './utils';
+
+// export { axiosOperation } from './utils/axiosOperation/index';
+// export function fn(arr: number[]) {
+//     const arr2 = [1, ...arr];
+
+//     const a = { ...{ A: 1 } };
+//     console.log(a, arr2);
+// }

package/src/indexFlags.ts

@@ -0,0 +1 @@
+export { useFlags } from './hooks/useFlags';

package/src/isolation/App.tsx

@@ -0,0 +1,24 @@
+//react
+
+// mui
+import { EnvironmentProvider } from '../contexts/EnvironmentContext';
+
+function App() {
+    return (
+        <EnvironmentProvider
+            {...{
+                isLocalhost: true,
+                host: 'h1',
+                domain_token: '1',
+                host_api_local: '2',
+                host_api_remote: '3',
+                host_static_assets: '4',
+                environment: '5',
+            }}
+        >
+            <div>Host tools</div>
+        </EnvironmentProvider>
+    );
+}
+
+export default App;

package/src/main.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './isolation/App';
+
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+ReactDOM.createRoot(document.getElementById('root')!).render(
+    <React.StrictMode>
+        <App />
+    </React.StrictMode>,
+);

package/src/prueba.d1.t1

@@ -0,0 +1,10 @@
+export { voidFunction } from './utils/voidFunction';
+
+export { EnvironmentProvider } from './contexts/EnvironmentContext';
+
+// export function fn(arr: number[]) {
+//     const arr2 = [1, ...arr];
+
+//     const a = { ...{ A: 1 } };
+//     console.log(a, arr2);
+// }

package/src/test/setup.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/src/test/utils.tsx

@@ -0,0 +1,20 @@
+import { cleanup, render } from '@testing-library/react';
+import React from 'react';
+import { afterEach } from 'vitest';
+
+afterEach(() => {
+    cleanup();
+});
+
+const customRender = (ui: React.ReactElement, options = {}) => {
+    return render(ui, {
+        // wrap provider(s) here if needed
+        wrapper: ({ children }) => children,
+        ...options,
+    });
+};
+
+export * from '@testing-library/react';
+export { default as userEvent } from '@testing-library/user-event';
+
+export { customRender as render };

package/{dist/types/dictionary.d.ts → src/types/dictionary.ts}

@@ -1,13 +1,17 @@
-export declare type GetLabelType = (key: string) => string;
+export type GetLabelType = (key: string) => string;
+
 export interface ComponentDictionary {
     [key: string]: string;
 }
+
 export interface Dictionary {
     [key: string]: ComponentDictionary | boolean | undefined | string;
 }
+
 export interface DataDictionary extends ComponentDictionary {
     module_name: string;
 }
+
 export interface ModuleDictionary extends Dictionary {
     data: DataDictionary;
 }

package/{dist/types/index.d.ts → src/types/index.ts}

@@ -1,5 +1,7 @@
+// import type { Method } from 'axios';
 import type { Id, ToastContent, ToastOptions } from 'react-toastify';
 import type { BrowserHistory } from 'history';
+
 export declare type Maybe<T> = T | undefined | null;
 export declare interface EnvironmentType {
     isLocalhost: boolean;
@@ -10,6 +12,7 @@ export declare interface EnvironmentType {
     host_static_assets: string;
     environment: string;
 }
+
 export declare type NetworkProps = {
     method: any;
     endPoint: string;
@@ -20,19 +23,31 @@ export declare type NetworkProps = {
     isRemote?: boolean;
     showSuccesInfo?: boolean;
 };
+
 export declare type ToastFunction = (content: ToastContent, options?: ToastOptions) => Id;
 export declare type EventFunListener = (...args: any[]) => void;
+
 export declare interface HostToolsType {
     history?: BrowserHistory;
-    toast: ToastFunction;
+    toast: ToastFunction; // Funcion for toast
     startProgress: VoidFunction;
     stopProgress: VoidFunction;
+
     events_add_listener: (eventName: string, handler: EventFunListener) => void;
     events_remove_listener: (eventName: string, handler: Maybe<EventFunListener>) => void;
     events_emit: (eventName: string, arg: any) => void;
 }
-export declare enum EmitEvents {
-    EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED = "netsevice_unauthorized",
-    EMMIT_EVENT_HOST_THEME_CHANGE = "host_theme_change"
+
+// eslint-disable-next-line no-shadow
+export enum EmitEvents {
+    EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED = `netsevice_unauthorized`,
+    EMMIT_EVENT_HOST_THEME_CHANGE = 'host_theme_change',
 }
-export declare type AxiosOperation = (props: NetworkProps, enviroment: EnvironmentType, hostTools: HostToolsType) => Promise<any>;
+
+export declare type AxiosOperation = (
+    props: NetworkProps,
+    enviroment: EnvironmentType,
+    hostTools: HostToolsType,
+) => Promise<any>;
+
+// export type { Method } from 'axios';

package/src/utils/axiosOperation/index.ts

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import axios from 'axios';
+import type { AxiosError } from 'axios';
+
+import snakecaseKeys from 'snakecase-keys';
+import { EmitEvents } from '../../types';
+import type { EnvironmentType, HostToolsType, NetworkProps } from '../../types';
+
+import { AxiosOperationError } from './types';
+
+// config
+
+// const axiosInstance = axios.create({});
+
+// ----------------------------------------------------------------------
+
+function getResponse(endPoint: string, response: any) {
+    console.log('Axios response', response, typeof response.data);
+
+    if (response && response.data && typeof response.data === 'object') {
+        if (
+            response.data.error &&
+            response.data.error?.code &&
+            response.data.error?.msg !== undefined
+        ) {
+            // Si respondió con codigo de error interno
+            return Promise.reject({ ...response.data.error, status: response.status });
+        }
+        return response.data;
+    }
+
+    return Promise.reject({
+        code: 1,
+        msg: `Incorrect endpoint: ${endPoint}`,
+        status: response.status,
+    });
+}
+
+function getError(error: any, hostTools: HostToolsType, checkUnAuthorized = true) {
+    const { toast } = hostTools;
+
+    let err: AxiosOperationError = {
+        message: '',
+        status: 1,
+        code: 0,
+    };
+
+    console.log('getError', error);
+    if (
+        error?.code !== undefined &&
+        err.status !== undefined &&
+        (error as any).message !== undefined
+    ) {
+        err = { ...err, ...error };
+    } else if (error?.response) {
+        // The request was made and the server responded with a status code
+        // that falls out of the range of 2xx
+        if (
+            error.response.data &&
+            typeof error.response.data === 'object' &&
+            error.response.data.error &&
+            error.response.data.error?.code &&
+            error.response.data.error?.message !== undefined
+        ) {
+            // Si respondió con codigo de error interno
+
+            err = { ...error.response.data.error, status: error.response.status };
+        } else {
+            err.message = error.message;
+            err.status = error.response.status;
+            err.code = 0;
+        }
+
+        if (checkUnAuthorized && error.response.status === 401) {
+            // unauthorized
+            hostTools.events_emit(EmitEvents.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, {});
+        }
+    } else if (error?.request) {
+        // The request was made but no response was received
+        // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+        // http.ClientRequest in node.js
+        err.message = `${error?.code} ${error.message}`;
+        err.code = -1;
+    } else {
+        // Something happened in setting up the request that triggered an Error
+        err.message = `${error?.code} ${error.message}`;
+        err.status = 0;
+        err.code = -2;
+    }
+
+    if (checkUnAuthorized) {
+        toast(`${err.message} - status: ${err.status} - code: ${err.code}`, { type: 'error' });
+    }
+
+    return err;
+}
+
+export const axiosOperation = async (
+    props: NetworkProps,
+    enviroment: EnvironmentType,
+    hostTools: HostToolsType,
+): Promise<any> => {
+    /// /console.log("Axios getWithParms request", endPoint);
+
+    const {
+        method,
+        endPoint,
+        timeout = 5000,
+        parms = {},
+        data = {},
+        isRemote = true,
+        checkUnAuthorized = true,
+    } = props;
+
+    let baseURL: string;
+
+    if (isRemote) {
+        baseURL = enviroment.host_api_remote;
+    } else {
+        baseURL = enviroment.host_api_local;
+    }
+
+    hostTools.startProgress();
+
+    return axios({
+        baseURL,
+        withCredentials: isRemote,
+        method,
+        url: `/${endPoint}`,
+        data: snakecaseKeys(data, { deep: true }),
+        params: snakecaseKeys(parms, { deep: true }),
+        timeout,
+    })
+        .then((response: any) => getResponse(endPoint, response))
+        .catch((error: AxiosError) => Promise.reject(getError(error, hostTools, checkUnAuthorized)))
+        .finally(() => {
+            hostTools.stopProgress();
+        });
+};

package/{dist/utils/axiosOperation/types.d.ts → src/utils/axiosOperation/types.ts}

@@ -1,4 +1,4 @@
-export declare type AxiosOperationError = {
+export type AxiosOperationError = {
     message: string;
     status: number;
     code: string | number;

package/src/utils/getLocalStorage.ts

@@ -0,0 +1,8 @@
+export function getLocalStorage<ValueType>(key: string, initialValue: ValueType): ValueType {
+    try {
+        const item = window.localStorage.getItem(key);
+        return item !== null ? JSON.parse(item) : initialValue;
+    } catch (e) {
+        return initialValue;
+    }
+}

package/src/utils/getPropertyByString.ts

@@ -0,0 +1,10 @@
+export function getPropertyByString(object: Record<string, unknown>, propString: string) {
+    let value: any = object;
+
+    const props = propString.split('.');
+    for (let index = 0; index < props.length; index += 1) {
+        if (props[index] === undefined) break;
+        value = value[props[index]];
+    }
+    return value;
+}

package/src/utils/setLocalStorage.ts

@@ -0,0 +1,12 @@
+export function setLocalStorage<ValueType>(key: string, value: ValueType) {
+    try {
+        const item: string | null = window.localStorage.getItem(key);
+
+        let newValue = item !== null ? JSON.parse(item) : {};
+        newValue = { ...newValue, ...value };
+
+        window.localStorage.setItem(key, JSON.stringify(newValue));
+    } catch (e) {
+        console.error(e);
+    }
+}

package/src/utils/voidFunction.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line prettier/prettier
+export function voidFunction() {}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    
+    "target": "esNext",
+    "useDefineForClassFields": true,
+    "lib": ["ESNext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": false,
+    "downlevelIteration":true,
+    "importHelpers": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ES2020",
+    "moduleResolution": "Node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "preserve",
+    "baseUrl": ".",
+    "importsNotUsedAsValues":"remove",
+    
+    "types":["jest"],
+    "paths": {
+      "@utils": [
+        "src/index.ts"
+      ],
+      "@testutils": [
+        "src/test/utils"
+      ]
+    }
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "esNext",
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["vite.config.ts","package.json"]
+}