@m4l/core 0.0.19 → 0.0.20

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/HostToolsContext/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { HostToolsType } from '../../types';
+import type { HostToolsProviderProps } from './types';
+declare const HostToolsContext: import("react").Context<HostToolsType>;
+declare function HostToolsProvider(props: HostToolsProviderProps): JSX.Element;
+export { HostToolsProvider, HostToolsContext };

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { HostToolsType } from '../../types';
+export interface HostToolsProviderProps extends HostToolsType {
+    children: ReactNode;
+}
+export declare type HostToolsContextType = HostToolsType;

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

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { NetworkProviderProps } from './types';
+declare const NetworkContext: import("react").Context<import("./types").NetworkType>;
+declare function NetworkProvider(props: NetworkProviderProps): JSX.Element;
+export { NetworkProvider, NetworkContext };

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

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { AxiosOperation, NetworkProps } from '../../types';
+export declare type EventFunListener = (...args: any[]) => void;
+export interface NetworkType {
+    networkOperation: (props: NetworkProps) => Promise<any>;
+}
+export interface NetworkProviderProps {
+    axiosOperation: AxiosOperation;
+    children: ReactNode;
+}
+export declare type NetworkContextType = NetworkType;

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/useHostTools/index.d.ts

@@ -0,0 +1,2 @@
+export declare const useHostTools: () => import("../..").HostToolsType;
+export default useHostTools;

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

@@ -0,0 +1 @@
+export declare function useLocalStorage<ValueType>(key: string, initialValue: ValueType): any[];

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

@@ -0,0 +1,2 @@
+export declare const useNetwork: () => import("../../contexts/NetworkContext/types").NetworkType;
+export default useNetwork;

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 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';
 export { EmitEvents } from './types';
 export type { Maybe, HostToolsType, NetworkProps, EnvironmentType, AxiosOperation, EventFunListener, } from './types';
 export type { GetLabelType, Dictionary, ModuleDictionary, ComponentDictionary, } from './types/dictionary';

package/dist/index.js

@@ -1,8 +1,8 @@
-import { createContext, useContext } from "react";
+import { createContext, useContext, useState } from "react";
 import "react/jsx-runtime";
 import { a as axios } from "./axios.js";
 import { s as snakecaseKeys } from "./snakecase-keys.js";
-const initialValue = {
+const initialValue$2 = {
   isLocalhost: true,
   host: "",
   domain_token: "",
@@ -11,20 +11,76 @@ const initialValue = {
   host_static_assets: "",
   environment: ""
 };
-const EnvironmentContext = createContext(initialValue);
+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 voidFunction() {
-}
 function getPropertyByString(object, propString) {
   let value = object;
   const props = propString.split(".");
@@ -130,4 +186,4 @@ const axiosOperation = async (props, enviroment, hostTools) => {
     hostTools.stopProgress();
   });
 };
-export { EmitEvents, axiosOperation, getLocalStorage, getPropertyByString, setLocalStorage, useEnvironment, voidFunction };
+export { EmitEvents, axiosOperation, getLocalStorage, getPropertyByString, setLocalStorage, useEnvironment, useFlags, useHostTools, useLocalStorage, useNetwork, voidFunction };

package/package.json

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