@m4l/core 0.0.24 → 0.0.25

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

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

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/{src/contexts/EnvironmentContext/types.ts → dist/contexts/EnvironmentContext/types.d.ts}

@@ -1,8 +1,6 @@
 import { ReactNode } from 'react';
 import { EnvironmentType } from '../../types';
-
 export interface EnvironmentProviderProps extends EnvironmentType {
     children: ReactNode;
 }
-
-export type EnvironmentContextType = EnvironmentType;
+export declare type EnvironmentContextType = EnvironmentType;

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/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/{src/contexts/FlagsContext/types.ts → dist/contexts/FlagsContext/types.d.ts}

@@ -1,14 +1,8 @@
 import { ReactNode } from 'react';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface FlagsProviderProps {
     children: ReactNode;
 }
-
-export type Flag = string;
-
-// Interface para almacenar el estado del contexto
-// Interface para indicar las propiedas y metodos que comparte el contexto
+export declare type Flag = string;
 export interface FlagsContextProps {
     flags: Array<Flag>;
     clearFlags: () => 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/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/{src/contexts/HostToolsContext/types.ts → dist/contexts/HostToolsContext/types.d.ts}

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

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/{src/contexts/ModuleDictionaryContext/types.ts → dist/contexts/ModuleDictionaryContext/types.d.ts}

@@ -1,16 +1,13 @@
 import { ReactNode } from 'react';
 import type { GetLabelType, ModuleDictionary } from 'src/types/dictionary';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface ModuleDictionaryProviderProps {
     currentLang?: string;
     isAuth?: boolean;
     moduleId: number;
-    moduleName?: string; //la llave donde reposa el nombre del modulo en el diccionario
+    moduleName?: string;
     componentsDictionary: string[];
     children: ReactNode;
 }
-
 export interface ModuleDictionaryContextProps {
     moduleDictionary?: ModuleDictionary;
     getLabel: GetLabelType;

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/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/{src/contexts/NetworkContext/types.ts → dist/contexts/NetworkContext/types.d.ts}

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