@m4l/core 0.0.2 → 0.0.5

package/dist/contexts/FlagsContext/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { FlagsContextProps, FlagsProviderProps } from './types';
+declare const FlagsContext: import("react").Context<FlagsContextProps>;
+declare function FlagsProvider({ children }: FlagsProviderProps): JSX.Element;
+export { FlagsProvider, FlagsContext };

package/dist/contexts/FlagsContext/types.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export interface FlagsProviderProps {
+    children: ReactNode;
+}
+export declare type Flag = string;
+export interface FlagsContextProps {
+    flags: Array<Flag>;
+    clearFlags: () => void;
+    addFlag: (flag: Flag) => void;
+}

package/dist/contexts/ModuleDictionaryContext/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { ModuleDictionaryContextProps, ModuleDictionaryProviderProps } from './types';
+declare const ModuleDictionaryContext: import("react").Context<ModuleDictionaryContextProps>;
+declare function ModuleDictionaryProvider(props: ModuleDictionaryProviderProps): JSX.Element;
+export { ModuleDictionaryProvider, ModuleDictionaryContext };

package/dist/contexts/ModuleDictionaryContext/types.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import type { GetLabelType, ModuleDictionary } from 'src/types/dictionary';
+export interface ModuleDictionaryProviderProps {
+    currentLang?: string;
+    isAuth?: boolean;
+    moduleId: number;
+    moduleName?: string;
+    componentsDictionary: string[];
+    children: ReactNode;
+}
+export interface ModuleDictionaryContextProps {
+    moduleDictionary?: ModuleDictionary;
+    getLabel: GetLabelType;
+    getModuleLabel: () => string;
+}

package/dist/contexts/index.d.ts

@@ -1,3 +1,5 @@
-export { EnvironmentContext } from './EnvironmentContext';
-export { HostToolsContext } from './HostToolsContext';
-export { NetworkContext } from './NetworkContext';
+export { EnvironmentContext, EnvironmentProvider } from './EnvironmentContext';
+export { HostToolsContext, HostToolsProvider } from './HostToolsContext';
+export { NetworkContext, NetworkProvider } from './NetworkContext';
+export { FlagsContext, FlagsProvider } from './FlagsContext';
+export { ModuleDictionaryContext, ModuleDictionaryProvider } from './ModuleDictionaryContext';

package/dist/hooks/index.d.ts

@@ -2,3 +2,5 @@ export { useLocalStorage } from './useLocalStorage/useLocalStorage';
 export { useHostTools } from './useHostTools';
 export { useNetwork } from './useNetwork';
 export { useEnvironment } from './useEnvironment';
+export { useFlags } from './useFlags';
+export { useModuleDictionary } from './useModuleDictionary';

package/dist/hooks/useFlags/index.d.ts

@@ -0,0 +1,3 @@
+import type { Flag, FlagsContextProps } from '../../contexts/FlagsContext/types';
+export declare const useFlags: () => FlagsContextProps;
+export declare const useFlagsPresent: (compareFlags: Array<Flag>) => boolean;

package/dist/hooks/useModuleDictionary/index.d.ts

@@ -0,0 +1 @@
+export declare const useModuleDictionary: () => import("../../contexts/ModuleDictionaryContext/types").ModuleDictionaryContextProps;

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from './contexts';
 export * from './hooks';
 export { EmitEvents } from './types';
 export type { Maybe, HostToolsType, NetworkProps, EnvironmentType } from './types';
+export type { GetLabelType, Dictionary, ModuleDictionary, ComponentDictionary, } from './types/dictionary';
 export * from './utils';

package/dist/index.js

@@ -17,8 +17,20 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { createContext, useContext, useState } from "react";
-import "react/jsx-runtime";
+var __objRest = (source2, exclude) => {
+  var target = {};
+  for (var prop in source2)
+    if (__hasOwnProp.call(source2, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source2[prop];
+  if (source2 != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source2)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source2, prop))
+        target[prop] = source2[prop];
+    }
+  return target;
+};
+import { createContext, useState, useContext, useCallback, useLayoutEffect } from "react";
+import { jsx } from "react/jsx-runtime";
 const initialValue$2 = {
   isLocalhost: true,
   host: "",
@@ -29,6 +41,18 @@ const initialValue$2 = {
   environment: ""
 };
 const EnvironmentContext = createContext(initialValue$2);
+function EnvironmentProvider(props) {
+  const _a = props, {
+    children
+  } = _a, other = __objRest(_a, [
+    "children"
+  ]);
+  const [finalEnvironment] = useState(other);
+  return /* @__PURE__ */ jsx(EnvironmentContext.Provider, {
+    value: finalEnvironment,
+    children
+  });
+}
 function voidFunction() {
 }
 function getPropertyByString(object, propString) {
@@ -1500,6 +1524,18 @@ const initialValue$1 = {
   events_emit: voidFunction
 };
 const HostToolsContext = createContext(initialValue$1);
+function HostToolsProvider(props) {
+  const _a = props, {
+    children
+  } = _a, hostTools = __objRest(_a, [
+    "children"
+  ]);
+  const [finalTools] = useState(hostTools);
+  return /* @__PURE__ */ jsx(HostToolsContext.Provider, {
+    value: finalTools,
+    children
+  });
+}
 const useEnvironment = () => {
   const context = useContext(EnvironmentContext);
   if (!context)
@@ -1516,6 +1552,53 @@ const initialValue = {
   networkOperation: () => Promise.resolve()
 };
 const NetworkContext = createContext(initialValue);
+function NetworkProvider(props) {
+  const {
+    children,
+    axiosOperation: axiosOperation2
+  } = props;
+  const environment = useEnvironment();
+  const hostTools = useHostTools();
+  const networkOperation = useCallback(async (networkProps) => {
+    return axiosOperation2(networkProps, environment, hostTools);
+  }, [axiosOperation2]);
+  return /* @__PURE__ */ jsx(NetworkContext.Provider, {
+    value: {
+      networkOperation
+    },
+    children
+  });
+}
+const initialState$1 = {
+  flags: [],
+  clearFlags: voidFunction,
+  addFlag: voidFunction
+};
+const FlagsContext = createContext(initialState$1);
+function FlagsProvider({
+  children
+}) {
+  const [flags, setFlags] = useState([]);
+  const clearFlags = useCallback(() => {
+    setFlags([]);
+  }, []);
+  const addFlag = useCallback((newFlag) => {
+    setFlags((oldFlags) => {
+      if (oldFlags.findIndex((f) => f === newFlag) < 0) {
+        return [...oldFlags, newFlag];
+      }
+      return [...oldFlags];
+    });
+  }, []);
+  return /* @__PURE__ */ jsx(FlagsContext.Provider, {
+    value: {
+      flags,
+      addFlag,
+      clearFlags
+    },
+    children
+  });
+}
 function useLocalStorage(key, initialValue2) {
   const [value, setValue] = useState(() => {
     try {
@@ -1541,4 +1624,94 @@ const useNetwork = () => {
     throw new Error("useNetwork context must be use inside NetworkContext");
   return context;
 };
-export { EmitEvents, EnvironmentContext, HostToolsContext, NetworkContext, axiosOperation, getLocalStorage, getPropertyByString, setLocalStorage, useEnvironment, useHostTools, useLocalStorage, useNetwork, voidFunction };
+const useFlags = () => {
+  const context = useContext(FlagsContext);
+  if (!context)
+    throw new Error("useFlags context must be use inside FlagsProvider");
+  return context;
+};
+const useModuleDictionary = () => {
+  const context = useContext(ModuleDictionaryContext);
+  if (!context)
+    throw new Error("useModuleDictionary context must be use inside ModuleDictionaryProvider");
+  return context;
+};
+const initialState = {
+  getLabel: () => "..",
+  getModuleLabel: () => "No dictionary context"
+};
+const ModuleDictionaryContext = createContext(initialState);
+function ModuleDictionaryProvider(props) {
+  const {
+    children,
+    componentsDictionary,
+    moduleId,
+    moduleName = "module_name",
+    currentLang = "us",
+    isAuth = true
+  } = props;
+  const {
+    addFlag
+  } = useFlags();
+  const [moduleDictionary, setModuleDictionary] = useState(void 0);
+  const {
+    domain_token
+  } = useEnvironment();
+  const {
+    startProgress,
+    stopProgress
+  } = useHostTools();
+  const {
+    networkOperation
+  } = useNetwork();
+  useLayoutEffect(() => {
+    let mounted = true;
+    startProgress();
+    networkOperation({
+      method: "GET",
+      endPoint: isAuth ? `dictionaries/${moduleId}` : `na/dictionaries/${moduleId}`,
+      parms: __spreadValues({
+        comps: componentsDictionary
+      }, isAuth ? {} : {
+        domain_token
+      })
+    }).then((response) => {
+      if (mounted) {
+        setModuleDictionary(__spreadValues({}, response));
+        addFlag("dictionary_loaded");
+      }
+    }).finally(() => {
+      stopProgress();
+    });
+    return function cleanUp() {
+      mounted = false;
+    };
+  }, [currentLang]);
+  const getLabel = useCallback((key) => {
+    if (moduleDictionary === void 0)
+      return "No dictionary";
+    if (key === void 0)
+      return "No key";
+    const parts = key.split(".");
+    if (parts.length === 2) {
+      if (moduleDictionary[parts[0]] && moduleDictionary[parts[0]][parts[1]]) {
+        return moduleDictionary[parts[0]][parts[1]];
+      }
+    } else if (parts.length === 1) {
+      if (moduleDictionary.data && moduleDictionary.data[key]) {
+        return moduleDictionary.data[key];
+      }
+    }
+    return `No dictionary:${key}`;
+  }, [moduleDictionary]);
+  const getModuleLabel = useCallback(() => getLabel(moduleName), [moduleName, getLabel]);
+  return /* @__PURE__ */ jsx(ModuleDictionaryContext.Provider, {
+    value: {
+      moduleDictionary,
+      getLabel,
+      getModuleLabel
+    },
+    children
+  });
+}
+export { EmitEvents, EnvironmentContext, EnvironmentProvider, FlagsContext, FlagsProvider, HostToolsContext, HostToolsProvider, ModuleDictionaryContext, ModuleDictionaryProvider, NetworkContext, NetworkProvider, axiosOperation, getLocalStorage, getPropertyByString, setLocalStorage, useEnvironment, useFlags, useHostTools, useLocalStorage, useModuleDictionary, useNetwork, voidFunction };

package/dist/types/dictionary.d.ts

@@ -0,0 +1,13 @@
+export declare 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@m4l/core",
   "private": false,
-  "version": "0.0.2",
+  "version": "0.0.5",
   "license": "UNLICENSED",
   "author": "M4L Team",
   "scripts": {
@@ -33,7 +33,6 @@
     "@typescript-eslint/parser": "^5.27.1",
     "@vitejs/plugin-react": "^1.3.0",
     "axios": "^0.27.2",
-    "c8": "^7.11.3",
     "eslint": "^8.17.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-import-resolver-alias": "^1.1.2",