@m4l/core 0.0.21 → 0.0.22

package/dist/EnvironmentContext.js

@@ -1,5 +1,5 @@
-import { createContext } from "react";
-import "react/jsx-runtime";
+import { createContext, useState } from "react";
+import { jsx } from "react/jsx-runtime";
 const initialValue = {
   isLocalhost: true,
   host: "",
@@ -10,4 +10,15 @@ const initialValue = {
   environment: ""
 };
 const EnvironmentContext = createContext(initialValue);
-export { EnvironmentContext as E };
+function EnvironmentProvider(props) {
+  const {
+    children,
+    ...other
+  } = props;
+  const [finalEnvironment] = useState(other);
+  return /* @__PURE__ */ jsx(EnvironmentContext.Provider, {
+    value: finalEnvironment,
+    children
+  });
+}
+export { EnvironmentContext as E, EnvironmentProvider as a };

package/dist/HostToolsContext.js

@@ -1,6 +1,6 @@
-import { createContext } from "react";
+import { createContext, useState } from "react";
 import { v as voidFunction } from "./voidFunction.js";
-import "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 const initialValue = {
   toast: () => 0,
   startProgress: voidFunction,
@@ -10,4 +10,15 @@ const initialValue = {
   events_emit: voidFunction
 };
 const HostToolsContext = createContext(initialValue);
-export { HostToolsContext as H };
+function HostToolsProvider(props) {
+  const {
+    children,
+    ...hostTools
+  } = props;
+  const [finalTools] = useState(hostTools);
+  return /* @__PURE__ */ jsx(HostToolsContext.Provider, {
+    value: finalTools,
+    children
+  });
+}
+export { HostToolsContext as H, HostToolsProvider as a };

package/dist/NetworkContext.js

@@ -1,9 +1,26 @@
-import { createContext } from "react";
-import "./EnvironmentContext.js";
-import "./HostToolsContext.js";
-import "react/jsx-runtime";
+import { createContext, useCallback } from "react";
+import { u as useEnvironment } from "./useEnvironment.js";
+import { u as useHostTools } from "./useHostTools.js";
+import { jsx } from "react/jsx-runtime";
 const initialValue = {
   networkOperation: () => Promise.resolve()
 };
 const NetworkContext = createContext(initialValue);
-export { NetworkContext as N };
+function NetworkProvider(props) {
+  const {
+    children,
+    axiosOperation
+  } = props;
+  const environment = useEnvironment();
+  const hostTools = useHostTools();
+  const networkOperation = useCallback(async (networkProps) => {
+    return axiosOperation(networkProps, environment, hostTools);
+  }, [axiosOperation]);
+  return /* @__PURE__ */ jsx(NetworkContext.Provider, {
+    value: {
+      networkOperation
+    },
+    children
+  });
+}
+export { NetworkContext as N, NetworkProvider as a };

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,6 @@
+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/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

@@ -1,4 +1,6 @@
+export * from './contexts';
 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';

package/dist/index.js

@@ -1,13 +1,13 @@
+export { E as EnvironmentContext, a as EnvironmentProvider } from "./EnvironmentContext.js";
+export { H as HostToolsContext, a as HostToolsProvider } from "./HostToolsContext.js";
+export { N as NetworkContext, a as NetworkProvider } from "./NetworkContext.js";
+export { E as EmitEvents, F as FlagsContext, a as FlagsProvider, M as ModuleDictionaryContext, b as ModuleDictionaryProvider, c as getLocalStorage, g as getPropertyByString, s as setLocalStorage, u as useFlags } from "./vendor.js";
 export { u as useEnvironment } from "./useEnvironment.js";
 export { u as useHostTools } from "./useHostTools.js";
 export { u as useLocalStorage } from "./useLocalStorage.js";
 export { u as useNetwork } from "./useNetwork.js";
-export { E as EmitEvents, a as getLocalStorage, g as getPropertyByString, s as setLocalStorage } from "./vendor.js";
 export { v as voidFunction } from "./voidFunction.js";
 export { a as axiosOperation } from "./axios.js";
 import "react";
-import "./EnvironmentContext.js";
 import "react/jsx-runtime";
-import "./HostToolsContext.js";
-import "./NetworkContext.js";
 import "./snakecase-keys.js";

package/dist/vendor.js

@@ -1,9 +1,131 @@
+import { createContext, useState, useCallback, useContext, useLayoutEffect } from "react";
+import "./HostToolsContext.js";
+import "./NetworkContext.js";
+import "./EnvironmentContext.js";
 import "./axios.js";
-import "./useEnvironment.js";
-import "./useHostTools.js";
+import { v as voidFunction } from "./voidFunction.js";
+import { jsx } from "react/jsx-runtime";
+import { u as useHostTools } from "./useHostTools.js";
+import { u as useNetwork } from "./useNetwork.js";
+import { u as useEnvironment } from "./useEnvironment.js";
 import "./useLocalStorage.js";
-import "./useNetwork.js";
-import "./voidFunction.js";
+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
+  });
+}
+const useFlags = () => {
+  const context = useContext(FlagsContext);
+  if (!context)
+    throw new Error("useFlags context must be use inside FlagsProvider");
+  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: {
+        comps: componentsDictionary,
+        ...isAuth ? {} : {
+          domain_token
+        }
+      }
+    }).then((response) => {
+      if (mounted) {
+        setModuleDictionary({
+          ...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
+  });
+}
 var EmitEvents = /* @__PURE__ */ ((EmitEvents2) => {
   EmitEvents2["EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED"] = `netsevice_unauthorized`;
   EmitEvents2["EMMIT_EVENT_HOST_THEME_CHANGE"] = "host_theme_change";
@@ -150,4 +272,4 @@ const dist_es2015 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   snakeCase
 }, Symbol.toStringTag, { value: "Module" }));
 const require$$1 = /* @__PURE__ */ getAugmentedNamespace(dist_es2015);
-export { EmitEvents as E, getLocalStorage as a, getPropertyByString as g, mapObj as m, require$$1 as r, setLocalStorage as s };
+export { EmitEvents as E, FlagsContext as F, ModuleDictionaryContext as M, FlagsProvider as a, ModuleDictionaryProvider as b, getLocalStorage as c, getPropertyByString as g, mapObj as m, require$$1 as r, setLocalStorage as s, useFlags as u };

package/package.json

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