@m4l/core 0.1.7 → 0.1.10

package/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/contexts/EnvironmentContext/index.js

@@ -0,0 +1,32 @@
+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_assets: "",
+  dfnsFormat: {
+    date_format: "yyyy-MM-dd",
+    date_mask: "____-__-__",
+    time_format: "HH:mm:ss",
+    time_mask: "__:__:__",
+    datetime_format: "yyyy-MM-dd HH:mm:ss",
+    datetime_mask: "____-__-__ __:__:__"
+  }
+};
+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/contexts/EnvironmentContext/types.d.ts

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

package/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/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/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/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/contexts/HostToolsContext/index.js

@@ -0,0 +1,25 @@
+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,
+  formatDate: () => "",
+  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/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/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/contexts/ModuleDictionaryContext/index.js

@@ -0,0 +1,90 @@
+import { createContext, useState, useEffect, useCallback } from "react";
+import { u as useEnvironment } from "../../hooks/useEnvironment/index.js";
+import { u as useFlags } from "../../hooks/useFlags/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import "../ModulePrivilegesContext/index.js";
+import "../ModuleSkeletonContext/index.js";
+import { u as useNetwork } from "../../hooks/useNetwork/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();
+  useEffect(() => {
+    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/contexts/ModuleDictionaryContext/types.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import type { GetLabelType, ModuleDictionary } from '../../types/dictionary';
+export interface ModuleDictionaryProviderProps {
+    currentLang?: string;
+    isAuth?: boolean;
+    moduleId: string;
+    moduleName?: string;
+    componentsDictionary: string[];
+    children: ReactNode;
+}
+export interface ModuleDictionaryContextProps {
+    moduleDictionary?: ModuleDictionary;
+    getLabel: GetLabelType;
+    getModuleLabel: () => string;
+}

package/contexts/ModulePrivilegesContext/index.d.ts

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

package/contexts/ModulePrivilegesContext/index.js

@@ -0,0 +1,68 @@
+import { createContext, useState, useEffect, useCallback } from "react";
+import "../EnvironmentContext/index.js";
+import { u as useFlags } from "../../hooks/useFlags/index.js";
+import { u as useHostTools } from "../../hooks/useHostTools/index.js";
+import "../ModuleDictionaryContext/index.js";
+import "../ModuleSkeletonContext/index.js";
+import { u as useNetwork } from "../../hooks/useNetwork/index.js";
+import { jsx } from "react/jsx-runtime";
+const initialState = {
+  privileges: {},
+  hasPrivilege: () => false
+};
+const ModulePrivilegesContext = createContext(initialState);
+function ModulePrivilegesProvider(props) {
+  const {
+    children,
+    queryPrivileges
+  } = props;
+  const {
+    addFlag
+  } = useFlags();
+  const [privileges, setPrivileges] = useState({});
+  const {
+    startProgress,
+    stopProgress
+  } = useHostTools();
+  const {
+    networkOperation
+  } = useNetwork();
+  useEffect(() => {
+    let mounted = true;
+    if (queryPrivileges.length === 0) {
+      addFlag("privileges_loaded");
+      return;
+    }
+    startProgress();
+    networkOperation({
+      method: "GET",
+      endPoint: `auth/login`,
+      parms: {
+        privileges: queryPrivileges
+      }
+    }).then((response) => {
+      if (mounted) {
+        setPrivileges({
+          ...response.data
+        });
+        addFlag("privileges_loaded");
+      }
+    }).finally(() => {
+      stopProgress();
+    });
+    return function cleanUp() {
+      mounted = false;
+    };
+  }, []);
+  const hasPrivilege = useCallback((key) => {
+    return key in privileges;
+  }, [privileges]);
+  return /* @__PURE__ */ jsx(ModulePrivilegesContext.Provider, {
+    value: {
+      hasPrivilege,
+      privileges
+    },
+    children
+  });
+}
+export { ModulePrivilegesContext as M, ModulePrivilegesProvider as a };

package/contexts/ModulePrivilegesContext/types.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+export interface ModulePrivilegesProviderProps {
+    queryPrivileges: string[];
+    children: ReactNode;
+}
+export interface ModulePrivilegesContextProps {
+    privileges: Record<string, boolean>;
+    hasPrivilege: (id: string) => boolean;
+}

package/contexts/ModuleSkeletonContext/index.d.ts

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

package/contexts/ModuleSkeletonContext/index.js

@@ -0,0 +1,26 @@
+import { createContext } from "react";
+import "../EnvironmentContext/index.js";
+import { a as useFlagsPresent } from "../../hooks/useFlags/index.js";
+import "../HostToolsContext/index.js";
+import "../ModuleDictionaryContext/index.js";
+import "../ModulePrivilegesContext/index.js";
+import "../NetworkContext/index.js";
+import { jsx } from "react/jsx-runtime";
+const initialState = {
+  isSkeleton: false
+};
+const ModuleSkeletonContext = createContext(initialState);
+function ModuleSkeletonProvider(props) {
+  const {
+    children,
+    flags
+  } = props;
+  const isSkeleton = !useFlagsPresent(flags);
+  return /* @__PURE__ */ jsx(ModuleSkeletonContext.Provider, {
+    value: {
+      isSkeleton
+    },
+    children
+  });
+}
+export { ModuleSkeletonContext as M, ModuleSkeletonProvider as a };

package/contexts/ModuleSkeletonContext/types.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+export interface ModuleSkeletonProviderProps {
+    flags: string[];
+    children: ReactNode;
+}
+export interface ModuleSkeletonContextProps {
+    isSkeleton: boolean;
+}

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

@@ -0,0 +1,7 @@
+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';
+export { ModulePrivilegesContext, ModulePrivilegesProvider } from './ModulePrivilegesContext';
+export { ModuleSkeletonContext, ModuleSkeletonProvider } from './ModuleSkeletonContext';