@m4l/core 0.0.20 → 0.0.23

package/dist/contexts/EnvironmentContext/index.js

@@ -0,0 +1,24 @@
+import { createContext, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+const initialValue = {
+  isLocalhost: true,
+  host: "",
+  domain_token: "",
+  host_api_local: "",
+  host_api_remote: "",
+  host_static_assets: "",
+  environment: ""
+};
+const EnvironmentContext = createContext(initialValue);
+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/contexts/FlagsContext/index.js

@@ -0,0 +1,34 @@
+import { createContext, useState, useCallback } from "react";
+import { v as voidFunction } from "../../utils/index.js";
+import { jsx } from "react/jsx-runtime";
+const initialState = {
+  flags: [],
+  clearFlags: voidFunction,
+  addFlag: voidFunction
+};
+const FlagsContext = createContext(initialState);
+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
+  });
+}
+export { FlagsContext as F, FlagsProvider as a };

package/dist/contexts/HostToolsContext/index.js

@@ -0,0 +1,24 @@
+import { createContext, useState } from "react";
+import { v as voidFunction } from "../../utils/index.js";
+import { jsx } from "react/jsx-runtime";
+const initialValue = {
+  toast: () => 0,
+  startProgress: voidFunction,
+  stopProgress: voidFunction,
+  events_add_listener: voidFunction,
+  events_remove_listener: voidFunction,
+  events_emit: voidFunction
+};
+const HostToolsContext = createContext(initialValue);
+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/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/index.js

@@ -0,0 +1,88 @@
+import { createContext, useState, useLayoutEffect, useCallback } from "react";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import { u as useNetwork } from "../../hooks/useNetwork/index.js";
+import { u as useEnvironment } from "../../hooks/useEnvironment/index.js";
+import { u as useFlags } from "../../hooks/useFlags/index.js";
+import { jsx } from "react/jsx-runtime";
+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
+  });
+}
+export { ModuleDictionaryContext as M, ModuleDictionaryProvider as a };

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/NetworkContext/index.js

@@ -0,0 +1,26 @@
+import { createContext, useCallback } from "react";
+import { u as useEnvironment } from "../../hooks/useEnvironment/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import { jsx } from "react/jsx-runtime";
+const initialValue = {
+  networkOperation: () => Promise.resolve()
+};
+const NetworkContext = createContext(initialValue);
+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/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/{axios.js → external/axios.js}

@@ -1,18 +1,5 @@
-function getAugmentedNamespace(n) {
-  if (n.__esModule)
-    return n;
-  var a = Object.defineProperty({}, "__esModule", { value: true });
-  Object.keys(n).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n, k);
-    Object.defineProperty(a, k, d.get ? d : {
-      enumerable: true,
-      get: function() {
-        return n[k];
-      }
-    });
-  });
-  return a;
-}
+import { s as snakecaseKeys } from "./snakecase-keys.js";
+import { E as EmitEvents } from "../types/index.js";
 var axios$2 = { exports: {} };
 var bind$2 = function bind(fn, thisArg) {
   return function wrap() {
@@ -1232,4 +1219,81 @@ axios$1.isAxiosError = isAxiosError;
 axios$2.exports = axios$1;
 axios$2.exports.default = axios$1;
 var axios = axios$2.exports;
-export { axios as a, getAugmentedNamespace as g };
+function getResponse(endPoint, response) {
+  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 !== void 0) {
+      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, hostTools, checkUnAuthorized = true) {
+  const { toast } = hostTools;
+  let err = {
+    message: "",
+    status: 1,
+    code: 0
+  };
+  console.log("getError", error);
+  if (error?.code !== void 0 && err.status !== void 0 && error.message !== void 0) {
+    err = { ...err, ...error };
+  } else if (error?.response) {
+    if (error.response.data && typeof error.response.data === "object" && error.response.data.error && error.response.data.error?.code && error.response.data.error?.message !== void 0) {
+      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) {
+      hostTools.events_emit(EmitEvents.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, {});
+    }
+  } else if (error?.request) {
+    err.message = `${error?.code} ${error.message}`;
+    err.code = -1;
+  } else {
+    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;
+}
+const axiosOperation = async (props, enviroment, hostTools) => {
+  const {
+    method,
+    endPoint,
+    timeout = 5e3,
+    parms = {},
+    data: data2 = {},
+    isRemote = true,
+    checkUnAuthorized = true
+  } = props;
+  let baseURL;
+  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(data2, { deep: true }),
+    params: snakecaseKeys(parms, { deep: true }),
+    timeout
+  }).then((response) => getResponse(endPoint, response)).catch((error) => Promise.reject(getError(error, hostTools, checkUnAuthorized))).finally(() => {
+    hostTools.stopProgress();
+  });
+};
+export { axiosOperation as a };

package/dist/external/snakecase-keys.js

@@ -0,0 +1,18 @@
+import { m as mapObj, r as require$$1 } from "../node_modules.js";
+const map = mapObj.exports;
+const { snakeCase } = require$$1;
+var snakecaseKeys = function(obj, options) {
+  options = Object.assign({ deep: true, exclude: [], parsingOptions: {} }, options);
+  return map(obj, function(key, val) {
+    return [
+      matches(options.exclude, key) ? key : snakeCase(key, options.parsingOptions),
+      val
+    ];
+  }, options);
+};
+function matches(patterns, value) {
+  return patterns.some(function(pattern) {
+    return typeof pattern === "string" ? pattern === value : pattern.test(value);
+  });
+}
+export { snakecaseKeys as s };

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/useEnvironment/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { E as EnvironmentContext } from "../../contexts/EnvironmentContext/index.js";
+const useEnvironment = () => {
+  const context = useContext(EnvironmentContext);
+  if (!context)
+    throw new Error("useEnvironment context must be use inside EnvironmentContext");
+  return context;
+};
+export { useEnvironment as u };

package/dist/hooks/useFlags/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { F as FlagsContext } from "../../contexts/FlagsContext/index.js";
+const useFlags = () => {
+  const context = useContext(FlagsContext);
+  if (!context)
+    throw new Error("useFlags context must be use inside FlagsProvider");
+  return context;
+};
+export { useFlags as u };

package/dist/hooks/useHostTools/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { H as HostToolsContext } from "../../contexts/HostToolsContext/index.js";
+const useHostTools = () => {
+  const context = useContext(HostToolsContext);
+  if (!context)
+    throw new Error("useHostTools context must be use inside HostToolsContext");
+  return context;
+};
+export { useHostTools as u };

package/dist/hooks/useLocalStorage/index.js

@@ -0,0 +1,21 @@
+import { useState } from "react";
+function useLocalStorage(key, initialValue) {
+  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) => {
+    try {
+      window.localStorage.setItem(key, JSON.stringify(newValue));
+      setValue(newValue);
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  return [value, setValueInLocalStorage];
+}
+export { useLocalStorage as u };

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

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

package/dist/hooks/useModuleDictionary/index.js

@@ -0,0 +1,2 @@
+import "react";
+import "../../contexts/ModuleDictionaryContext/index.js";

package/dist/hooks/useNetwork/index.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { N as NetworkContext } from "../../contexts/NetworkContext/index.js";
+const useNetwork = () => {
+  const context = useContext(NetworkContext);
+  if (!context)
+    throw new Error("useNetwork context must be use inside NetworkContext");
+  return context;
+};
+export { useNetwork as u };

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './contexts';
 export { useEnvironment } from './hooks/useEnvironment';
 export { useFlags } from './hooks/useFlags';
 export { useHostTools } from './hooks/useHostTools';

package/dist/index.js

@@ -1,189 +1,18 @@
-import { createContext, useContext, useState } from "react";
+export { E as EnvironmentContext, a as EnvironmentProvider } from "./contexts/EnvironmentContext/index.js";
+export { H as HostToolsContext, a as HostToolsProvider } from "./contexts/HostToolsContext/index.js";
+export { N as NetworkContext, a as NetworkProvider } from "./contexts/NetworkContext/index.js";
+export { F as FlagsContext, a as FlagsProvider } from "./contexts/FlagsContext/index.js";
+export { M as ModuleDictionaryContext, a as ModuleDictionaryProvider } from "./contexts/ModuleDictionaryContext/index.js";
+export { u as useEnvironment } from "./hooks/useEnvironment/index.js";
+export { u as useFlags } from "./hooks/useFlags/index.js";
+export { u as useHostTools } from "./hooks/useHostTools/index.js";
+export { u as useLocalStorage } from "./hooks/useLocalStorage/index.js";
+export { u as useNetwork } from "./hooks/useNetwork/index.js";
+export { E as EmitEvents } from "./types/index.js";
+export { a as getLocalStorage, g as getPropertyByString, s as setLocalStorage, v as voidFunction } from "./utils/index.js";
+export { a as axiosOperation } from "./external/axios.js";
+import "react";
 import "react/jsx-runtime";
-import { a as axios } from "./axios.js";
-import { s as snakecaseKeys } from "./snakecase-keys.js";
-const initialValue$2 = {
-  isLocalhost: true,
-  host: "",
-  domain_token: "",
-  host_api_local: "",
-  host_api_remote: "",
-  host_static_assets: "",
-  environment: ""
-};
-const EnvironmentContext = createContext(initialValue$2);
-const useEnvironment = () => {
-  const context = useContext(EnvironmentContext);
-  if (!context)
-    throw new Error("useEnvironment context must be use inside EnvironmentContext");
-  return context;
-};
-function voidFunction() {
-}
-const initialState = {
-  flags: [],
-  clearFlags: voidFunction,
-  addFlag: voidFunction
-};
-const FlagsContext = createContext(initialState);
-const useFlags = () => {
-  const context = useContext(FlagsContext);
-  if (!context)
-    throw new Error("useFlags context must be use inside FlagsProvider");
-  return context;
-};
-const initialValue$1 = {
-  toast: () => 0,
-  startProgress: voidFunction,
-  stopProgress: voidFunction,
-  events_add_listener: voidFunction,
-  events_remove_listener: voidFunction,
-  events_emit: voidFunction
-};
-const HostToolsContext = createContext(initialValue$1);
-const useHostTools = () => {
-  const context = useContext(HostToolsContext);
-  if (!context)
-    throw new Error("useHostTools context must be use inside HostToolsContext");
-  return context;
-};
-function useLocalStorage(key, initialValue2) {
-  const [value, setValue] = useState(() => {
-    try {
-      const item = window.localStorage.getItem(key);
-      return item !== null ? JSON.parse(item) : initialValue2;
-    } catch (e) {
-      return initialValue2;
-    }
-  });
-  const setValueInLocalStorage = (newValue) => {
-    try {
-      window.localStorage.setItem(key, JSON.stringify(newValue));
-      setValue(newValue);
-    } catch (e) {
-      console.error(e);
-    }
-  };
-  return [value, setValueInLocalStorage];
-}
-const initialValue = {
-  networkOperation: () => Promise.resolve()
-};
-const NetworkContext = createContext(initialValue);
-const useNetwork = () => {
-  const context = useContext(NetworkContext);
-  if (!context)
-    throw new Error("useNetwork context must be use inside NetworkContext");
-  return context;
-};
-var EmitEvents = /* @__PURE__ */ ((EmitEvents2) => {
-  EmitEvents2["EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED"] = `netsevice_unauthorized`;
-  EmitEvents2["EMMIT_EVENT_HOST_THEME_CHANGE"] = "host_theme_change";
-  return EmitEvents2;
-})(EmitEvents || {});
-function getPropertyByString(object, propString) {
-  let value = object;
-  const props = propString.split(".");
-  for (let index = 0; index < props.length; index += 1) {
-    if (props[index] === void 0)
-      break;
-    value = value[props[index]];
-  }
-  return value;
-}
-function getLocalStorage(key, initialValue2) {
-  try {
-    const item = window.localStorage.getItem(key);
-    return item !== null ? JSON.parse(item) : initialValue2;
-  } catch (e) {
-    return initialValue2;
-  }
-}
-function setLocalStorage(key, value) {
-  try {
-    const item = 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);
-  }
-}
-function getResponse(endPoint, response) {
-  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 !== void 0) {
-      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, hostTools, checkUnAuthorized = true) {
-  const { toast } = hostTools;
-  let err = {
-    message: "",
-    status: 1,
-    code: 0
-  };
-  console.log("getError", error);
-  if (error?.code !== void 0 && err.status !== void 0 && error.message !== void 0) {
-    err = { ...err, ...error };
-  } else if (error?.response) {
-    if (error.response.data && typeof error.response.data === "object" && error.response.data.error && error.response.data.error?.code && error.response.data.error?.message !== void 0) {
-      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) {
-      hostTools.events_emit(EmitEvents.EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED, {});
-    }
-  } else if (error?.request) {
-    err.message = `${error?.code} ${error.message}`;
-    err.code = -1;
-  } else {
-    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;
-}
-const axiosOperation = async (props, enviroment, hostTools) => {
-  const {
-    method,
-    endPoint,
-    timeout = 5e3,
-    parms = {},
-    data = {},
-    isRemote = true,
-    checkUnAuthorized = true
-  } = props;
-  let baseURL;
-  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) => getResponse(endPoint, response)).catch((error) => Promise.reject(getError(error, hostTools, checkUnAuthorized))).finally(() => {
-    hostTools.stopProgress();
-  });
-};
-export { EmitEvents, axiosOperation, getLocalStorage, getPropertyByString, setLocalStorage, useEnvironment, useFlags, useHostTools, useLocalStorage, useNetwork, voidFunction };
+import "./node_modules.js";
+import "./vendor.js";
+import "./external/snakecase-keys.js";

package/dist/{snakecase-keys.js → node_modules.js}

@@ -1,4 +1,4 @@
-import { g as getAugmentedNamespace } from "./axios.js";
+import { g as getAugmentedNamespace } from "./vendor.js";
 var mapObj = { exports: {} };
 const isObject = (value) => typeof value === "object" && value !== null;
 const mapObjectSkip = Symbol("skip");
@@ -86,7 +86,7 @@ function dotCase(input, options) {
   }
   return noCase(input, __assign({ delimiter: "." }, options));
 }
-function snakeCase$1(input, options) {
+function snakeCase(input, options) {
   if (options === void 0) {
     options = {};
   }
@@ -94,23 +94,7 @@ function snakeCase$1(input, options) {
 }
 const dist_es2015 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  snakeCase: snakeCase$1
+  snakeCase
 }, Symbol.toStringTag, { value: "Module" }));
 const require$$1 = /* @__PURE__ */ getAugmentedNamespace(dist_es2015);
-const map = mapObj.exports;
-const { snakeCase } = require$$1;
-var snakecaseKeys = function(obj, options) {
-  options = Object.assign({ deep: true, exclude: [], parsingOptions: {} }, options);
-  return map(obj, function(key, val) {
-    return [
-      matches(options.exclude, key) ? key : snakeCase(key, options.parsingOptions),
-      val
-    ];
-  }, options);
-};
-function matches(patterns, value) {
-  return patterns.some(function(pattern) {
-    return typeof pattern === "string" ? pattern === value : pattern.test(value);
-  });
-}
-export { snakecaseKeys as s };
+export { mapObj as m, require$$1 as r };

package/dist/types/index.js

@@ -0,0 +1,6 @@
+var EmitEvents = /* @__PURE__ */ ((EmitEvents2) => {
+  EmitEvents2["EMMIT_EVENT_NET_SERVICE_UNAUTHORIZED"] = `netsevice_unauthorized`;
+  EmitEvents2["EMMIT_EVENT_HOST_THEME_CHANGE"] = "host_theme_change";
+  return EmitEvents2;
+})(EmitEvents || {});
+export { EmitEvents as E };

package/dist/utils/index.js

@@ -0,0 +1,33 @@
+import "../external/axios.js";
+import "../node_modules.js";
+function voidFunction() {
+}
+function getPropertyByString(object, propString) {
+  let value = object;
+  const props = propString.split(".");
+  for (let index = 0; index < props.length; index += 1) {
+    if (props[index] === void 0)
+      break;
+    value = value[props[index]];
+  }
+  return value;
+}
+function getLocalStorage(key, initialValue) {
+  try {
+    const item = window.localStorage.getItem(key);
+    return item !== null ? JSON.parse(item) : initialValue;
+  } catch (e) {
+    return initialValue;
+  }
+}
+function setLocalStorage(key, value) {
+  try {
+    const item = 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);
+  }
+}
+export { getLocalStorage as a, getPropertyByString as g, setLocalStorage as s, voidFunction as v };

package/dist/vendor.js

@@ -0,0 +1,30 @@
+import "react";
+import "./contexts/HostToolsContext/index.js";
+import "./contexts/NetworkContext/index.js";
+import "./contexts/EnvironmentContext/index.js";
+import "./contexts/FlagsContext/index.js";
+import "./contexts/ModuleDictionaryContext/index.js";
+import "./hooks/useEnvironment/index.js";
+import "./hooks/useFlags/index.js";
+import "./hooks/useHostTools/index.js";
+import "./hooks/useLocalStorage/index.js";
+import "./hooks/useNetwork/index.js";
+import "./types/index.js";
+import "./utils/index.js";
+import "./external/axios.js";
+function getAugmentedNamespace(n) {
+  if (n.__esModule)
+    return n;
+  var a = Object.defineProperty({}, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+export { getAugmentedNamespace as g };

package/package.json

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