@m4l/components 0.1.42 → 0.1.45

package/components/areas/contexts/AreasContext/index.d.ts

@@ -1,5 +1,13 @@
 /// <reference types="react" />
-import { AreasContextProps, AreasProviderProps } from './types';
-declare const AreasContext: import("react").Context<AreasContextProps | null>;
+import { AreasProviderProps } from './types';
+declare const AreasContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<import("./store").AreasStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("./store").AreasStateWithActions | Partial<import("./store").AreasStateWithActions> | ((state: import("./store").AreasStateWithActions) => import("./store").AreasStateWithActions | Partial<import("./store").AreasStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("./store").AreasStateWithActions | Partial<import("./store").AreasStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./store").AreasStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
 declare function AreasProvider(props: AreasProviderProps): JSX.Element;
 export { AreasProvider, AreasContext };

package/components/areas/contexts/AreasContext/store.d.ts

@@ -0,0 +1,38 @@
+import { AreaProviderRef } from '../AreaContext/types';
+import { AreaType } from '../../components/Area/types';
+import { GetLabelType, NetworkProps } from '@m4l/core';
+import { WritableDraft } from 'immer/dist/internal';
+export declare type AreasStatus = 'init' | 'loading' | 'loaded' | 'error';
+export interface AreasState {
+    networkOperation: (props: NetworkProps) => Promise<any>;
+    getLabel: GetLabelType;
+    loadAreasFromNetwork: boolean;
+    currentArea: string;
+    status: AreasStatus;
+    areas: AreaType[];
+}
+export interface AreasStateWithActions extends AreasState {
+    actions: {
+        addArea: () => string;
+        deleteArea: (areaId: string) => void;
+        selectArea: (newAreaId: string) => void;
+    };
+    internalActions: {
+        setHandlerGetLabel: (newHandler: GetLabelType) => void;
+        loadFromApi: () => void;
+        setAreaRef: (areaId: string, ref: AreaProviderRef) => void;
+    };
+}
+declare type DefaultStoreProps = Omit<AreasState, 'currentArea'>;
+declare type InitialStoreProps = Pick<AreasState, 'networkOperation' | 'loadAreasFromNetwork' | 'getLabel'> & Partial<DefaultStoreProps>;
+export declare const createAreasStore: (initProps: InitialStoreProps) => Omit<Omit<import("zustand").StoreApi<AreasStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: AreasStateWithActions | Partial<AreasStateWithActions> | ((state: AreasStateWithActions) => AreasStateWithActions | Partial<AreasStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: AreasStateWithActions | Partial<AreasStateWithActions> | ((state: WritableDraft<AreasStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare type AreasStore = ReturnType<typeof createAreasStore>;
+export {};

package/components/areas/contexts/AreasContext/types.d.ts

@@ -1,18 +1,6 @@
 import { ReactNode } from 'react';
-import { AreaType } from '../../components/Area/types';
-import { AreaProviderRef } from '../AreaContext/types';
-export declare type AreasStatus = 'init' | 'loading' | 'loaded' | 'error';
 export interface AreasProviderProps {
     children: ReactNode;
-    activeAreasNetwork: boolean;
+    loadAreasFromNetwork: boolean;
     onLoad?: () => void;
 }
-export interface AreasContextProps extends Omit<AreasProviderProps, 'children' | 'onLoad'> {
-    currentArea: string;
-    status: AreasStatus;
-    addArea: () => string;
-    deleteArea: (areaId: string) => void;
-    selectArea: (newAreaId: string) => void;
-    areas: AreaType[];
-    setAreaRef: (areaId: string, ref: AreaProviderRef) => void;
-}

package/components/areas/contexts/DynamicMFParmsContext/index.c19cb8cc.js

@@ -0,0 +1,43 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import React__default, { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+const createDynamicMFStore = (initProps) => {
+  const startProps = {
+    ...initProps
+  };
+  return createStore(
+    devtools(
+      immer((set, _get) => ({
+        ...startProps,
+        actions: {
+          changeData: (newDynamicMFState) => {
+            set((state) => {
+              state.dynamicMFParameters = newDynamicMFState;
+            });
+          }
+        }
+      })),
+      { name: `dyamic store ${initProps.windowId}` }
+    )
+  );
+};
+const DynamicMFParmsContext = createContext(null);
+function DynamicMFParmsProvider(props) {
+  const {
+    children,
+    store
+  } = props;
+  return /* @__PURE__ */ jsx(DynamicMFParmsContext.Provider, {
+    value: store,
+    children
+  });
+}
+const MemonizedDynamicMFParmsProvider = React__default.memo(DynamicMFParmsProvider);
+export {
+  DynamicMFParmsProvider as D,
+  MemonizedDynamicMFParmsProvider as M,
+  DynamicMFParmsContext as a,
+  createDynamicMFStore as c
+};

package/components/areas/contexts/DynamicMFParmsContext/index.d.ts

@@ -1,5 +1,14 @@
-/// <reference types="react" />
-import { DynamicMFParmsContextProps, DynamicMFParmsProviderProps } from './types';
-declare const DynamicMFParmsContext: import("react").Context<DynamicMFParmsContextProps | null>;
+import React from 'react';
+import { DynamicMFParmsProviderProps } from './types';
+declare const DynamicMFParmsContext: React.Context<(Omit<Omit<import("zustand").StoreApi<import("./store").DynamicMFStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("./store").DynamicMFStateWithActions | Partial<import("./store").DynamicMFStateWithActions> | ((state: import("./store").DynamicMFStateWithActions) => import("./store").DynamicMFStateWithActions | Partial<import("./store").DynamicMFStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("./store").DynamicMFStateWithActions | Partial<import("./store").DynamicMFStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./store").DynamicMFStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
 declare function DynamicMFParmsProvider(props: DynamicMFParmsProviderProps): JSX.Element;
-export { DynamicMFParmsProvider, DynamicMFParmsContext };
+declare const MemonizedDynamicMFParmsProvider: React.MemoExoticComponent<typeof DynamicMFParmsProvider>;
+export { DynamicMFParmsProvider, DynamicMFParmsContext, MemonizedDynamicMFParmsProvider };

package/components/areas/contexts/DynamicMFParmsContext/store.d.ts

@@ -0,0 +1,20 @@
+import { DynamicMFParameters } from '..';
+export interface DynamicMFState {
+    dynamicMFParameters: DynamicMFParameters;
+    windowId: string;
+}
+export interface DynamicMFStateWithActions extends DynamicMFState {
+    actions: {
+        changeData: (newDynamicMFState: DynamicMFParameters) => void;
+    };
+}
+export declare const createDynamicMFStore: (initProps: DynamicMFState) => Omit<Omit<import("zustand").StoreApi<DynamicMFStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: DynamicMFStateWithActions | Partial<DynamicMFStateWithActions> | ((state: DynamicMFStateWithActions) => DynamicMFStateWithActions | Partial<DynamicMFStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: DynamicMFStateWithActions | Partial<DynamicMFStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<DynamicMFStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare type DynamicMFStore = ReturnType<typeof createDynamicMFStore>;

package/components/areas/contexts/DynamicMFParmsContext/types.d.ts

@@ -1,19 +1,7 @@
 import { ReactNode } from 'react';
-import { MenuAction } from '../../../mui_extended';
-export declare type WindowActionType = 'main' | 'allways' | 'normal';
-export interface ModuleAction extends MenuAction {
-    visibility: WindowActionType;
-    tag?: any;
-    className?: string;
-}
-export declare type IsolationDynamicMFParameters = Record<string, any>;
-export interface DynamicMFParameters extends IsolationDynamicMFParameters {
-    setModuleActions: (newActions: ModuleAction[]) => void;
-}
-export interface DynamicMFParameters extends IsolationDynamicMFParameters {
-    setModuleActions: (newActions: ModuleAction[]) => void;
-}
-export interface DynamicMFParmsProviderProps extends DynamicMFParameters {
+import { DynamicMFStore } from './store';
+export declare type DynamicMFParameters = Record<string, any>;
+export interface DynamicMFParmsProviderProps {
+    store: DynamicMFStore;
     children: ReactNode;
 }
-export declare type DynamicMFParmsContextProps = Omit<DynamicMFParmsProviderProps, 'children'>;

package/components/areas/contexts/WindowContext/helper.d.ts

@@ -0,0 +1 @@
+export declare function getCookiesContainer(data: any, containerId: string): Record<string, any>;

package/components/areas/contexts/WindowContext/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { WindowProviderProps } from './types';
+declare const WindowContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<import("./store").WindowStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("./store").WindowStateWithActions | Partial<import("./store").WindowStateWithActions> | ((state: import("./store").WindowStateWithActions) => import("./store").WindowStateWithActions | Partial<import("./store").WindowStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("./store").WindowStateWithActions | Partial<import("./store").WindowStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./store").WindowStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
+declare function WindowMFProvider(props: WindowProviderProps): JSX.Element;
+export { WindowMFProvider, WindowContext };

package/components/areas/contexts/WindowContext/store.d.ts

@@ -0,0 +1,31 @@
+import { ModuleAction, WindowToolsMF } from '..';
+import { Cookies, WindowBaseProps } from '../../components/Area/types';
+import { NetworkProps } from '@m4l/core';
+import { DynamicMFStore } from '../DynamicMFParmsContext/store';
+export declare type WindowStatus = 'init' | 'loaded' | 'error';
+export interface WindowState extends WindowBaseProps {
+    status: WindowStatus;
+    dynamicMFStore: DynamicMFStore;
+    moduleActions: ModuleAction[];
+    networkOperation: (props: NetworkProps) => Promise<any>;
+    cookies: Cookies;
+}
+export interface WindowStateWithActions extends WindowState {
+    actions: WindowToolsMF;
+    internalActions: {
+        loadCookiesFromApi: () => void;
+        saveModuleCookies: () => void;
+    };
+}
+declare type InitialStoreProps = Omit<WindowState, 'moduleActions' | 'cookies' | 'status'>;
+export declare const createWindowStore: (initProps: InitialStoreProps) => Omit<Omit<import("zustand").StoreApi<WindowStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: WindowStateWithActions | Partial<WindowStateWithActions> | ((state: WindowStateWithActions) => WindowStateWithActions | Partial<WindowStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: WindowStateWithActions | Partial<WindowStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<WindowStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare type WindowStore = ReturnType<typeof createWindowStore>;
+export {};

package/components/areas/contexts/WindowContext/types.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+import { WindowBaseProps } from '../../components/Area/types';
+export interface WindowProviderProps extends WindowBaseProps {
+    children: ReactNode;
+}

package/components/areas/contexts/WindowToolsMFContext/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { WindowToolsMFContextProps, WindowToolsMFProviderProps } from './types';
+declare const WindowToolsMFContext: React.Context<WindowToolsMFContextProps | null>;
+declare function WindowToolsMFProvider(props: WindowToolsMFProviderProps): JSX.Element;
+declare const MemonizedWindowToolsMFContext: React.MemoExoticComponent<typeof WindowToolsMFProvider>;
+export { WindowToolsMFProvider, WindowToolsMFContext, MemonizedWindowToolsMFContext };

package/components/areas/contexts/WindowToolsMFContext/types.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { MenuAction } from '../../../mui_extended';
+import { CookieType } from '../../components/Area/types';
+export declare type WindowActionType = 'main' | 'allways' | 'normal';
+export interface ModuleAction extends MenuAction {
+    visibility: WindowActionType;
+    tag?: any;
+    className?: string;
+}
+export interface WindowToolsMF {
+    getCookie: (id: string) => Record<string, any> | undefined;
+    getWindowId: () => string;
+    getCookies: (type: CookieType) => Record<string, any>;
+    setActions: (newActions: ModuleAction[]) => void;
+    setCookie: (id: string, type: CookieType, cookie: Record<string, any>) => void;
+    close: () => void;
+}
+export interface WindowToolsMFProviderProps extends WindowToolsMF {
+    children: ReactNode;
+}
+export declare type WindowToolsMFContextProps = Omit<WindowToolsMFProviderProps, 'children'>;

package/components/areas/contexts/index.9c342ce6.js

@@ -0,0 +1,203 @@
+import { useNetwork } from "@m4l/core";
+import React__default, { createContext, useRef, useEffect } from "react";
+import { c as createDynamicMFStore } from "./DynamicMFParmsContext/index.c19cb8cc.js";
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import cloneDeep from "lodash.clonedeep";
+import { jsx } from "react/jsx-runtime";
+import "./AreasContext/index.1b624579.js";
+function getCookiesContainer(data, containerId) {
+  const cookies = {};
+  try {
+    if (Array.isArray(data)) {
+      for (let i = 0; i < data.length; i++) {
+        if (data[i]?.container_id === containerId && data[i]?.id) {
+          cookies[data[i]?.id] = JSON.parse(data[i].value);
+        }
+      }
+    }
+  } catch (error) {
+  }
+  return cookies;
+}
+const createWindowStore = (initProps) => {
+  const startProps = {
+    status: "init",
+    moduleActions: [],
+    cookies: initProps.devCookies || { moduleCookies: {}, windowCookies: {} },
+    ...initProps
+  };
+  delete startProps.devCookies;
+  return createStore(
+    devtools(
+      immer((set, get) => ({
+        ...startProps,
+        actions: {
+          setActions: (newActions) => {
+            set((state) => {
+              state.moduleActions = cloneDeep(newActions);
+            });
+          },
+          close: () => {
+            const onClose = get().onClose;
+            if (onClose) {
+              onClose(get().windowId);
+            }
+          },
+          getWindowId: () => {
+            return get().windowId;
+          },
+          getCookie: (id) => {
+            return get().cookies.windowCookies[id] || get().cookies.moduleCookies[id];
+          },
+          getCookies: (type) => {
+            if (type === "window") {
+              return get().cookies.windowCookies;
+            } else {
+              return get().cookies.moduleCookies;
+            }
+          },
+          setCookie: (id, type, cookie) => {
+            get().networkOperation({
+              method: "PUT",
+              endPoint: `cookies/${type === "module" ? get().moduleId : get().windowId}/${id}`,
+              data: {
+                value: JSON.stringify(cookie)
+              },
+              toastSuccess: false,
+              toastError: false
+            });
+            set((state) => {
+              if (type === "window") {
+                state.cookies.windowCookies[id] = cookie;
+              } else {
+                state.cookies.moduleCookies[id] = cookie;
+              }
+            });
+          }
+        },
+        internalActions: {
+          loadCookiesFromApi: () => {
+            console.log("loadCookiesFromApi start");
+            if (get().status === "init") {
+              get().networkOperation({
+                method: "GET",
+                endPoint: `cookies`,
+                parms: {
+                  f: [
+                    { n: "container_id", o: "e", o1: get().windowId },
+                    { n: "container_id", o: "e", o1: get().moduleId }
+                  ]
+                },
+                toastSuccess: false,
+                toastError: false
+              }).then((response) => {
+                set((state) => {
+                  state.cookies.moduleCookies = getCookiesContainer(
+                    response.data,
+                    state.moduleId
+                  );
+                  state.cookies.windowCookies = getCookiesContainer(
+                    response.data,
+                    state.windowId
+                  );
+                  console.log(
+                    "loadCookiesFromApi end",
+                    state.cookies.moduleCookies
+                  );
+                  state.status = "loaded";
+                });
+              }).catch((_response) => {
+                set((state) => {
+                  state.status = "loaded";
+                });
+              });
+            }
+          },
+          saveModuleCookies: () => {
+            console.log("saveModuleCookies end", get().cookies.moduleCookies);
+            for (const key in get().cookies.windowCookies) {
+              const cookie = get().cookies.windowCookies[key];
+              get().networkOperation({
+                method: "PUT",
+                endPoint: `cookies/${get().moduleId}/${key}`,
+                data: {
+                  value: JSON.stringify(cookie)
+                },
+                toastSuccess: false,
+                toastError: false
+              });
+            }
+          }
+        }
+      })),
+      { name: `window store ${initProps.windowId}` }
+    )
+  );
+};
+const WindowContext = createContext(null);
+function WindowMFProvider(props) {
+  const {
+    children,
+    ...other
+  } = props;
+  const {
+    networkOperation
+  } = useNetwork();
+  const windowStoreRef = useRef();
+  const dynamicMFStoreRef = useRef();
+  if (!dynamicMFStoreRef.current) {
+    dynamicMFStoreRef.current = createDynamicMFStore({
+      dynamicMFParameters: props.dynamicParams,
+      windowId: props.windowId
+    });
+  }
+  if (!windowStoreRef.current) {
+    windowStoreRef.current = createWindowStore({
+      ...other,
+      dynamicMFStore: dynamicMFStoreRef.current,
+      networkOperation
+    });
+  }
+  useEffect(() => {
+    windowStoreRef.current?.getState().internalActions.loadCookiesFromApi();
+  }, []);
+  useEffect(() => {
+    if (windowStoreRef.current?.getState().status === "loaded") {
+      console.log("useEffect Reemplazo de ventan");
+      dynamicMFStoreRef.current?.getState().actions.changeData(props.dynamicParams);
+    }
+  }, [props.dynamicParams]);
+  console.log("Render WindowProvider");
+  return /* @__PURE__ */ jsx(WindowContext.Provider, {
+    value: windowStoreRef.current,
+    children
+  });
+}
+const WindowToolsMFContext = createContext(null);
+function WindowToolsMFProvider(props) {
+  const {
+    children,
+    setActions,
+    ...other
+  } = props;
+  useEffect(() => {
+    console.log("useEffect {DynamicMFParmsProvider}", other);
+  }, []);
+  console.log("Render WindowToolsMFProvider", other);
+  return /* @__PURE__ */ jsx(WindowToolsMFContext.Provider, {
+    value: {
+      setActions,
+      ...other
+    },
+    children
+  });
+}
+React__default.memo(WindowToolsMFProvider);
+export {
+  WindowToolsMFProvider as W,
+  WindowMFProvider as a,
+  WindowContext as b,
+  WindowToolsMFContext as c
+};

package/components/areas/contexts/index.d.ts

@@ -1,2 +1,5 @@
 export * from './AreasContext';
-export type { DynamicMFParameters, IsolationDynamicMFParameters, ModuleAction, } from './DynamicMFParmsContext/types';
+export type { DynamicMFParameters } from './DynamicMFParmsContext/types';
+export type { DynamicMFStore } from './DynamicMFParmsContext/store';
+export { WindowToolsMFProvider, WindowToolsMFContext } from './WindowToolsMFContext';
+export type { WindowToolsMF, ModuleAction } from './WindowToolsMFContext/types';

package/components/areas/hooks/index.4e59c40f.js

@@ -0,0 +1,27 @@
+import { useContext } from "react";
+import { useStore } from "zustand";
+import { b as WindowContext, c as WindowToolsMFContext } from "../contexts/index.9c342ce6.js";
+import "../contexts/DynamicMFParmsContext/index.c19cb8cc.js";
+const useWindow = () => {
+  const context = useContext(WindowContext);
+  if (!context)
+    throw new Error("useWindow context must be use inside WindowContext");
+  return context;
+};
+function useWindowStore(selector, equalityFn) {
+  const store = useContext(WindowContext);
+  if (!store)
+    throw new Error("useWindow context must be use inside WindowContext");
+  return useStore(store, selector, equalityFn);
+}
+const useWindowToolsMF = () => {
+  const context = useContext(WindowToolsMFContext);
+  if (!context)
+    throw new Error("useWindowToolsMF context must be use inside WindowToolsMFContext");
+  return context;
+};
+export {
+  useWindow as a,
+  useWindowStore as b,
+  useWindowToolsMF as u
+};

package/components/areas/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useDynamicMFParametersStore } from './useDynamicMFParameters';
+export { useWindowToolsMF } from './useWindowToolsMF';

package/components/areas/hooks/useArea/index.d.ts

@@ -1 +1,3 @@
+import { AreaStateWithActions } from '../../contexts/AreaContext/store';
 export declare const useArea: () => import("../../contexts/AreaContext/types").AreaContextProps;
+export declare function useAreaStore<T>(selector: (state: AreaStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;

package/components/areas/hooks/useArea/index.df7c7169.js

@@ -0,0 +1,20 @@
+import { useContext } from "react";
+import { useStore } from "zustand";
+import { a as AreaContext } from "../../contexts/AreaContext/index.cb686ae0.js";
+import { A as AreasContext } from "../../contexts/AreasContext/index.1b624579.js";
+function useAreaStore(selector, equalityFn) {
+  const context = useContext(AreaContext);
+  if (!context)
+    throw new Error("useAreaStore context must be use inside AreaContext");
+  return useStore(context.store, selector, equalityFn);
+}
+function useAreasStore(selector, equalityFn) {
+  const context = useContext(AreasContext);
+  if (!context)
+    throw new Error("useAreasStore context must be use inside AreasContext");
+  return useStore(context, selector, equalityFn);
+}
+export {
+  useAreaStore as a,
+  useAreasStore as u
+};

package/components/areas/hooks/useAreas/index.d.ts

@@ -1,2 +1,12 @@
-export declare function useAreas(): import("../../contexts/AreasContext/types").AreasContextProps;
+import { AreasStateWithActions } from '../../contexts/AreasContext/store';
+export declare function useAreas(): Omit<Omit<import("zustand").StoreApi<AreasStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: AreasStateWithActions | Partial<AreasStateWithActions> | ((state: AreasStateWithActions) => AreasStateWithActions | Partial<AreasStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: AreasStateWithActions | Partial<AreasStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<AreasStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare function useAreasStore<T>(selector: (state: AreasStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;
 export default useAreas;

package/components/areas/hooks/useDynamicMFParameters/index.041a666b.js

@@ -0,0 +1,14 @@
+import { useContext } from "react";
+import { useStore } from "zustand";
+import { a as DynamicMFParmsContext } from "../../contexts/DynamicMFParmsContext/index.c19cb8cc.js";
+function useDynamicMFParametersStore(selector, equalityFn) {
+  const store = useContext(DynamicMFParmsContext);
+  if (!store)
+    throw new Error(
+      "useDynamicMFParametersStore context must be use inside DynamicMFParmsContext"
+    );
+  return useStore(store, selector, equalityFn);
+}
+export {
+  useDynamicMFParametersStore as u
+};

package/components/areas/hooks/useDynamicMFParameters/index.d.ts

@@ -1 +1,11 @@
-export declare const useDynamicMFParameters: () => import("../../contexts/DynamicMFParmsContext/types").DynamicMFParmsContextProps;
+import { DynamicMFState } from '../../contexts/DynamicMFParmsContext/store';
+export declare const useDynamicMFParameters: () => Omit<Omit<import("zustand").StoreApi<import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions | Partial<import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions> | ((state: import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions) => import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions | Partial<import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions | Partial<import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("../../contexts/DynamicMFParmsContext/store").DynamicMFStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare function useDynamicMFParametersStore<T>(selector: (state: DynamicMFState) => T, equalityFn?: (left: T, right: T) => boolean): T;

package/components/areas/hooks/useWindow/index.d.ts

@@ -0,0 +1,11 @@
+import { WindowStateWithActions } from '../../contexts/WindowContext/store';
+export declare const useWindow: () => Omit<Omit<import("zustand").StoreApi<WindowStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: WindowStateWithActions | Partial<WindowStateWithActions> | ((state: WindowStateWithActions) => WindowStateWithActions | Partial<WindowStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: WindowStateWithActions | Partial<WindowStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<WindowStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export declare function useWindowStore<T>(selector: (state: WindowStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;

package/components/areas/hooks/useWindowToolsMF/index.d.ts

@@ -0,0 +1 @@
+export declare const useWindowToolsMF: () => import("../../contexts/WindowToolsMFContext/types").WindowToolsMFContextProps;

package/components/areas/index.7b430c19.js

@@ -0,0 +1,21 @@
+import "./components/index.e9971ebf.js";
+import "./components/AreasAdmin/index.01739b1f.js";
+import "react";
+import "@m4l/core";
+import "@mui/material";
+import "../Icon/index.f6e8d810.js";
+import "@mui/material/styles";
+import "react/jsx-runtime";
+import "../mui_extended/IconButton/index.1318a283.js";
+import "zustand";
+import "./contexts/AreasContext/index.1b624579.js";
+import "zustand/shallow";
+import "./components/AreasContainer/index.41fb511e.js";
+import "react-grid-layout/css/styles.css";
+import "../../react-resizable.bb58c8fc.js";
+import "./contexts/index.9c342ce6.js";
+import "./contexts/DynamicMFParmsContext/index.c19cb8cc.js";
+const LABEL_NEW_AREA = "label_new_area";
+export {
+  LABEL_NEW_AREA as L
+};

package/components/areas/index.d.ts

@@ -1,2 +1,3 @@
 export * from './components';
 export * from './contexts';
+export * from './hooks';

package/components/formatters/BooleanFormatter/{index.3a9b16c8.js → index.b3fb8a75.js}

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
 import { useModuleDictionary, useEnvironment } from "@m4l/core";
-import { I as Icon } from "../../Icon/index.8d754623.js";
+import { I as Icon } from "../../Icon/index.f6e8d810.js";
 import { W as WrapperComponent } from "../../WrapperComponent/index.5e872594.js";
 import { jsx } from "react/jsx-runtime";
 function BooleanFormatter(props) {