@m4l/core 0.0.3 → 0.0.6

package/dist/contexts/index.d.ts

@@ -1,5 +1,5 @@
-export { EnvironmentContext } from './EnvironmentContext';
-export { HostToolsContext } from './HostToolsContext';
-export { NetworkContext } from './NetworkContext';
-export { FlagsContext } from './FlagsContext';
-export { ModuleDictionaryContext } from './ModuleDictionaryContext';
+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,5 +2,5 @@ export { useLocalStorage } from './useLocalStorage/useLocalStorage';
 export { useHostTools } from './useHostTools';
 export { useNetwork } from './useNetwork';
 export { useEnvironment } from './useEnvironment';
-export { useFlags } from './useFlags';
+export { useFlags, useFlagsPresent } from './useFlags';
 export { useModuleDictionary } from './useModuleDictionary';

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, useEffect, 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,12 +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 {
@@ -1553,6 +1630,20 @@ const useFlags = () => {
     throw new Error("useFlags context must be use inside FlagsProvider");
   return context;
 };
+function isFlagsPresent(compareFlags, flags) {
+  const filterFlags = compareFlags.filter((findFlag) => flags.findIndex((sFlag) => sFlag === findFlag) !== -1);
+  return filterFlags.length === compareFlags.length;
+}
+const useFlagsPresent = (compareFlags) => {
+  const context = useFlags();
+  const [isPresent, setIsPresent] = useState(isFlagsPresent(compareFlags, context.flags));
+  useEffect(() => {
+    if (isFlagsPresent(compareFlags, context.flags)) {
+      setIsPresent(true);
+    }
+  }, [context.flags, compareFlags]);
+  return isPresent;
+};
 const useModuleDictionary = () => {
   const context = useContext(ModuleDictionaryContext);
   if (!context)
@@ -1564,4 +1655,77 @@ const initialState = {
   getModuleLabel: () => "No dictionary context"
 };
 const ModuleDictionaryContext = createContext(initialState);
-export { EmitEvents, EnvironmentContext, FlagsContext, HostToolsContext, ModuleDictionaryContext, NetworkContext, axiosOperation, getLocalStorage, getPropertyByString, setLocalStorage, useEnvironment, useFlags, useHostTools, useLocalStorage, useModuleDictionary, useNetwork, voidFunction };
+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, useFlagsPresent, useHostTools, useLocalStorage, useModuleDictionary, useNetwork, voidFunction };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@m4l/core",
   "private": false,
-  "version": "0.0.3",
+  "version": "0.0.6",
   "license": "UNLICENSED",
   "author": "M4L Team",
   "scripts": {