@m4l/components 0.1.40 → 0.1.41

package/components/areas/contexts/AreasContext/index.cd8e4bee.js

@@ -0,0 +1,158 @@
+import { createContext, useState, useRef, useCallback, useEffect } from "react";
+import { useHostTools, useModuleDictionary, useNetwork, EmitEvents } from "@m4l/core";
+import { L as LABEL_NEW_AREA } from "../../index.d1bf612c.js";
+import { jsx } from "react/jsx-runtime";
+const AreasContext = createContext(null);
+function AreasProvider(props) {
+  const {
+    children,
+    activeAreasNetwork,
+    onLoad
+  } = props;
+  const [areas, setAreas] = useState([]);
+  const {
+    events_add_listener,
+    events_remove_listener
+  } = useHostTools();
+  const {
+    getLabel
+  } = useModuleDictionary();
+  const [status, setStatus] = useState("init");
+  const {
+    networkOperation
+  } = useNetwork();
+  const [currentArea, setCurrentArea] = useState(areas.length > 0 ? areas[0].id : "");
+  const currentAreaRef = useRef(areas.length > 0 ? areas[0].id : "");
+  const areaRefs = useRef({});
+  const addWindow = useCallback((newWindow) => {
+    let current;
+    console.log("addWindow raw");
+    if (areaRefs.current && areaRefs.current[currentAreaRef.current]) {
+      current = areaRefs.current[currentAreaRef.current];
+    }
+    if (current && current.addWindow) {
+      current.addWindow(newWindow);
+    }
+  }, []);
+  const addArea = useCallback(() => {
+    const newId = `area_${new Date().getTime()}_${(Math.random() * 1e3).toFixed(0)}`;
+    const newName = `${getLabel(LABEL_NEW_AREA)} ${areas.length + 1}`;
+    setAreas((lastAreas) => [...lastAreas, {
+      id: newId,
+      url_icon: "",
+      name: newName,
+      loadWindows: false
+    }]);
+    selectArea(newId);
+    if (activeAreasNetwork) {
+      networkOperation({
+        method: "POST",
+        endPoint: `areas`,
+        data: {
+          id: newId,
+          name: newName
+        },
+        toastSuccess: false,
+        toastError: false
+      });
+    }
+    return newId;
+  }, [getLabel]);
+  useEffect(() => {
+    events_add_listener(EmitEvents.EMMIT_EVENT_HOST_EMERGE_WINDOW, addWindow);
+    console.log("useEffect AreasProvider Emmiter");
+    return () => {
+      events_remove_listener(EmitEvents.EMMIT_EVENT_HOST_EMERGE_WINDOW, addWindow);
+    };
+  }, []);
+  useEffect(() => {
+    let mounted = true;
+    if (status === "init") {
+      if (activeAreasNetwork) {
+        setStatus("loading");
+        networkOperation({
+          method: "GET",
+          endPoint: `areas`,
+          parms: {},
+          toastSuccess: false
+        }).then((response) => {
+          if (mounted) {
+            if (response?.data && Array.isArray(response.data) && response.data.length > 0) {
+              setAreas(response.data);
+              selectArea(response.data[0].id);
+            } else {
+              addArea();
+            }
+          }
+        }).finally(() => {
+          setStatus("loaded");
+        });
+      } else {
+        addArea();
+        setStatus("loaded");
+      }
+    }
+    console.log("useEffect AreasProvider");
+    return () => {
+      console.log("useEffect cluanUp AreasProvider *** no deber\xEDa darse");
+      mounted = false;
+    };
+  }, []);
+  useEffect(() => {
+    if (status === "loaded") {
+      console.log("useEffect Areas loaded");
+      onLoad && onLoad();
+    }
+  }, [status]);
+  const selectArea = (newId) => {
+    currentAreaRef.current = newId;
+    setCurrentArea(newId);
+  };
+  const deleteArea = (areaId) => {
+    let newAreas = [];
+    setAreas((lastAreas) => {
+      newAreas = [...lastAreas];
+      newAreas = lastAreas.filter((area) => area.id !== areaId);
+      return newAreas;
+    });
+    if (currentAreaRef.current === areaId) {
+      if (newAreas.length > 0) {
+        selectArea(newAreas[0].id);
+      } else {
+        selectArea("");
+      }
+    }
+    if (activeAreasNetwork) {
+      networkOperation({
+        method: "DELETE",
+        endPoint: `areas/${areaId}`,
+        parms: {},
+        toastSuccess: false,
+        toastError: false
+      });
+    }
+  };
+  const setAreaRef = (areaId, ref) => {
+    console.log("setAreaRef", areaRefs.current[areaId] === ref, areaRefs.current[areaId]?.addWindow === ref?.addWindow, JSON.stringify(areaRefs.current[areaId]) === JSON.stringify(ref), areaRefs.current[areaId], ref);
+    if (areaRefs.current[areaId] !== ref) {
+      areaRefs.current[areaId] = ref;
+    }
+  };
+  return /* @__PURE__ */ jsx(AreasContext.Provider, {
+    value: {
+      status,
+      activeAreasNetwork,
+      areas,
+      currentArea,
+      addArea,
+      deleteArea,
+      selectArea,
+      setAreaRef
+    },
+    children
+  });
+}
+export {
+  AreasContext as A,
+  AreasProvider as a
+};

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

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { AreasContextProps, AreasProviderProps } from './types';
+declare const AreasContext: import("react").Context<AreasContextProps | null>;
+declare function AreasProvider(props: AreasProviderProps): JSX.Element;
+export { AreasProvider, AreasContext };

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

@@ -0,0 +1,18 @@
+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;
+    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.668bc2e2.js

@@ -0,0 +1,17 @@
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+const DynamicMFParmsContext = createContext(null);
+function DynamicMFParmsProvider(props) {
+  const {
+    children,
+    ...other
+  } = props;
+  return /* @__PURE__ */ jsx(DynamicMFParmsContext.Provider, {
+    value: other,
+    children
+  });
+}
+export {
+  DynamicMFParmsProvider as D,
+  DynamicMFParmsContext as a
+};

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

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { DynamicMFParmsContextProps, DynamicMFParmsProviderProps } from './types';
+declare const DynamicMFParmsContext: import("react").Context<DynamicMFParmsContextProps | null>;
+declare function DynamicMFParmsProvider(props: DynamicMFParmsProviderProps): JSX.Element;
+export { DynamicMFParmsProvider, DynamicMFParmsContext };

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

@@ -0,0 +1,19 @@
+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 {
+    children: ReactNode;
+}
+export declare type DynamicMFParmsContextProps = Omit<DynamicMFParmsProviderProps, 'children'>;

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

@@ -0,0 +1,2 @@
+export * from './AreasContext';
+export type { DynamicMFParameters, IsolationDynamicMFParameters, ModuleAction, } from './DynamicMFParmsContext/types';

package/components/areas/contexts/index.f9196fb2.js

@@ -0,0 +1 @@
+import "./AreasContext/index.cd8e4bee.js";

package/components/areas/dictionary.d.ts

@@ -0,0 +1,14 @@
+export declare const MODULE_NAME_ADD = "module_name_add";
+export declare const MODULE_NAME_EDIT = "module_name_edit";
+export declare const LABEL_NEW_AREA = "label_new_area";
+export declare const LABEL_DELETE_AREA = "label_delete_area";
+export declare const MODAL_DELETE_MESSAGE = "modal_delete_message";
+export declare const MODAL_DELETE_TITLE = "modal_delete_title";
+export declare const ROW_ACTION_EDIT = "row_action_edit";
+export declare const ROW_ACTION_DELETE = "row_action_delete";
+export declare const LABEL_ID = "label_id";
+export declare const ACCORDION_BASIC_INFORMATION = "accordion_basic_information";
+export declare const ACCORDION_CONTACT_DATA = "accordion_contact_data";
+export declare const LABEL_ROLE_NAME = "label_role_name";
+export declare const LABEL_PRIVILEGE_NAME = "label_privilege_name";
+export declare const LABEL_PRIVILEGE_ACTIVE = "label_privilege_active";

package/components/areas/hooks/useArea/index.9b85ce24.js

@@ -0,0 +1,19 @@
+import { useContext } from "react";
+import { A as AreasContext } from "../../contexts/AreasContext/index.cd8e4bee.js";
+import { a as AreaContext } from "../../contexts/AreaContext/index.4894cf23.js";
+function useAreas() {
+  const context = useContext(AreasContext);
+  if (!context)
+    throw new Error("useAreas context must be use inside AreasContext");
+  return context;
+}
+const useArea = () => {
+  const context = useContext(AreaContext);
+  if (!context)
+    throw new Error("useArea context must be use inside AreaContext");
+  return context;
+};
+export {
+  useArea as a,
+  useAreas as u
+};

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

@@ -0,0 +1 @@
+export declare const useArea: () => import("../../contexts/AreaContext/types").AreaContextProps;

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

@@ -0,0 +1,2 @@
+export declare function useAreas(): import("../../contexts/AreasContext/types").AreasContextProps;
+export default useAreas;

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

@@ -0,0 +1 @@
+export declare const useDynamicMFParameters: () => import("../../contexts/DynamicMFParmsContext/types").DynamicMFParmsContextProps;

package/components/areas/hooks/useDynamicMFParameters/index.e6a44ae3.js

@@ -0,0 +1,11 @@
+import { useContext } from "react";
+import { a as DynamicMFParmsContext } from "../../contexts/DynamicMFParmsContext/index.668bc2e2.js";
+const useDynamicMFParameters = () => {
+  const context = useContext(DynamicMFParmsContext);
+  if (!context)
+    throw new Error("useDynamicMFParameters context must be use inside DynamicMFParmsContext");
+  return context;
+};
+export {
+  useDynamicMFParameters as u
+};

package/components/areas/index.d1bf612c.js

@@ -0,0 +1,16 @@
+import "./components/index.7d6cd649.js";
+import "./components/AreasAdmin/index.6794b22f.js";
+import "react";
+import "@m4l/core";
+import "@mui/material";
+import "../Icon/index.8d754623.js";
+import "@mui/material/styles";
+import "react/jsx-runtime";
+import "./contexts/AreasContext/index.cd8e4bee.js";
+import "./components/AreasContainer/index.a2f8899b.js";
+import "react-grid-layout/css/styles.css";
+import "../../react-resizable.1d00271d.js";
+const LABEL_NEW_AREA = "label_new_area";
+export {
+  LABEL_NEW_AREA as L
+};

package/components/formatters/BooleanFormatter/index.3a9b16c8.js

@@ -0,0 +1,44 @@
+import { useMemo } from "react";
+import { useModuleDictionary, useEnvironment } from "@m4l/core";
+import { I as Icon } from "../../Icon/index.8d754623.js";
+import { W as WrapperComponent } from "../../WrapperComponent/index.5e872594.js";
+import { jsx } from "react/jsx-runtime";
+function BooleanFormatter(props) {
+  const {
+    presentationType,
+    value,
+    Component = WrapperComponent
+  } = props;
+  const {
+    getLabel
+  } = useModuleDictionary();
+  const {
+    host_static_assets,
+    environment_assets
+  } = useEnvironment();
+  const final_value = value ?? false;
+  const srcCheckTrue = `${host_static_assets}/${environment_assets}/frontend/components/data_grid/components/boolean_formatter/assets/icons/check_true.svg`;
+  const srcCheckFalse = `${host_static_assets}/${environment_assets}/frontend/components/data_grid/components/boolean_formatter/assets/icons/check_false.svg`;
+  const memoComponent = useMemo(() => {
+    if (presentationType === "string_yes_no") {
+      return /* @__PURE__ */ jsx(Component, {
+        children: final_value ? getLabel("formatters.boolean_yes") : getLabel("formatters.boolean_no")
+      });
+    }
+    if (presentationType === "string_true_false") {
+      return /* @__PURE__ */ jsx(Component, {
+        children: final_value ? getLabel("formatters.boolean_true") : getLabel("formatters.boolean_false")
+      });
+    }
+    return /* @__PURE__ */ jsx(Component, {
+      children: /* @__PURE__ */ jsx(Icon, {
+        src: final_value ? srcCheckTrue : srcCheckFalse,
+        bgColor: "action.disabled"
+      })
+    });
+  }, [final_value]);
+  return memoComponent;
+}
+export {
+  BooleanFormatter as B
+};

package/components/formatters/BooleanFormatter/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { BooleanFormatterProps } from './types';
+export declare function BooleanFormatter(props: BooleanFormatterProps): JSX.Element;

package/components/formatters/BooleanFormatter/types.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare type PresentationType = 'string_yes_no' | 'string_true_false' | 'check';
+export interface BooleanFormatterProps {
+    Component?: React.ElementType;
+    presentationType: PresentationType;
+    value?: boolean;
+}

package/components/formatters/DateFormatter/index.80522f69.js

@@ -0,0 +1,49 @@
+import { useFormatter } from "@m4l/graphics";
+import { W as WrapperComponent } from "../../WrapperComponent/index.5e872594.js";
+import { jsx, Fragment } from "react/jsx-runtime";
+function DateFormatter(props) {
+  const {
+    presentationType,
+    value,
+    format,
+    Component = WrapperComponent
+  } = props;
+  const {
+    dateFormatter
+  } = useFormatter();
+  let finalFormat = format || dateFormatter.datetimeFormat;
+  let result;
+  let resultDate;
+  if (value === void 0 || value === null) {
+    return /* @__PURE__ */ jsx(Fragment, {
+      children: "-"
+    });
+  }
+  switch (presentationType) {
+    case "datetime":
+      finalFormat = format || dateFormatter.datetimeFormat;
+      break;
+    case "date":
+      finalFormat = format || dateFormatter.dateFormat;
+      break;
+    case "time":
+      finalFormat = format || dateFormatter.timeFormat;
+      break;
+  }
+  try {
+    if (typeof value === "number" || typeof value === "string") {
+      resultDate = new Date(value);
+    } else {
+      resultDate = value;
+    }
+    result = dateFormatter.formatDate(resultDate, finalFormat);
+  } catch (e) {
+    result = "err_typing";
+  }
+  return /* @__PURE__ */ jsx(Component, {
+    children: result
+  });
+}
+export {
+  DateFormatter as D
+};

package/components/formatters/DateFormatter/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { DateFormatterProps } from './types';
+export declare function DateFormatter(props: DateFormatterProps): JSX.Element;

package/components/formatters/DateFormatter/types.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { Maybe } from '@m4l/core';
+export declare type PresentationType = 'date' | 'datetime' | 'time';
+export interface DateFormatterProps {
+    Component?: React.ElementType;
+    presentationType: PresentationType;
+    format?: string;
+    value: Maybe<Date | string | number>;
+}

package/components/formatters/PointsFormatter/index.80a4e414.js

@@ -0,0 +1,32 @@
+import { getPropertyByString } from "@m4l/core";
+import { W as WrapperComponent } from "../../WrapperComponent/index.5e872594.js";
+import { jsx } from "react/jsx-runtime";
+function getFormatPoints(obProps, fieldValue, fieldUnit) {
+  let result = "";
+  const points = getPropertyByString(obProps, fieldValue);
+  const unit = getPropertyByString(obProps, fieldUnit) || "";
+  if (points === void 0 || points === null || !Array.isArray(points)) {
+    return "[]";
+  }
+  points.map((point) => {
+    if (point) {
+      result = result.concat(`[${point}${unit}]`);
+    }
+  });
+  return result;
+}
+function PointsFormatter(props) {
+  const {
+    obProps,
+    fieldValue,
+    fieldUnit,
+    Component = WrapperComponent
+  } = props;
+  return /* @__PURE__ */ jsx(Component, {
+    children: getFormatPoints(obProps, fieldValue, fieldUnit)
+  });
+}
+export {
+  PointsFormatter as P,
+  getFormatPoints as g
+};

package/components/formatters/PointsFormatter/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { PointsFormatterProps } from './types';
+export declare function getFormatPoints(obProps: any, fieldValue: string, fieldUnit: string): string;
+export declare function PointsFormatter(props: PointsFormatterProps): JSX.Element;

package/components/formatters/PointsFormatter/types.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare type CalibrationPoint = number | null;
+export interface PointsFormatterProps {
+    Component?: React.ElementType;
+    obProps: any;
+    fieldUnit: string;
+    fieldValue: string;
+}

package/components/formatters/PriceFormatter/index.83cbe7be.js

@@ -0,0 +1,43 @@
+import { getPropertyByString } from "@m4l/core";
+import { useFormatter } from "@m4l/graphics";
+import { W as WrapperComponent } from "../../WrapperComponent/index.5e872594.js";
+import { jsx } from "react/jsx-runtime";
+function getFormatPrice(obProps, fieldValue, currency, decimalDigits) {
+  let result = "";
+  const value = getPropertyByString(obProps, fieldValue);
+  try {
+    result = Number(value).toLocaleString(navigator.language, {
+      currency,
+      style: "currency",
+      currencyDisplay: "symbol",
+      useGrouping: true,
+      maximumFractionDigits: decimalDigits
+    }) || "";
+  } catch (error) {
+    result = Number(value).toLocaleString("en-US", {
+      style: "currency",
+      currency: "USD",
+      currencyDisplay: "symbol",
+      useGrouping: true,
+      maximumFractionDigits: decimalDigits
+    }) || "";
+  }
+  return result;
+}
+function PriceFormatter(props) {
+  const {
+    obProps,
+    fieldValue,
+    Component = WrapperComponent
+  } = props;
+  const {
+    currencyFormatter
+  } = useFormatter();
+  return /* @__PURE__ */ jsx(Component, {
+    children: getFormatPrice(obProps, fieldValue, currencyFormatter.code, currencyFormatter.decimalDigits)
+  });
+}
+export {
+  PriceFormatter as P,
+  getFormatPrice as g
+};

package/components/formatters/PriceFormatter/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { PriceFormatterProps } from './types';
+export declare function getFormatPrice(obProps: any, fieldValue: string, currency: string, decimalDigits: number): string;
+export declare function PriceFormatter(props: PriceFormatterProps): JSX.Element;

package/components/formatters/PriceFormatter/types.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface PriceFormatterProps {
+    Component?: React.ElementType;
+    obProps: any;
+    fieldValue: string;
+}

package/components/formatters/UncertaintyFormatter/index.08e1b79f.js

@@ -0,0 +1,34 @@
+import { getPropertyByString } from "@m4l/core";
+import { W as WrapperComponent } from "../../WrapperComponent/index.5e872594.js";
+import { jsx } from "react/jsx-runtime";
+function getUncertaintyFormat(obProps, fieldValue, fieldSymbol, fieldUnit) {
+  let result = "";
+  const ranges = getPropertyByString(obProps, fieldValue);
+  const symbol = getPropertyByString(obProps, fieldSymbol);
+  const unit = getPropertyByString(obProps, fieldUnit);
+  if (ranges === void 0 || ranges === null || !Array.isArray(ranges) || typeof symbol !== "string" || typeof unit !== "string") {
+    return "[]";
+  }
+  ranges.map((obj, idx) => {
+    const cmc_min_closed = obj.cmc_min_closed != true ? "<" : "\u2264";
+    const cmc_max_closed = obj.cmc_max_closed != true ? "<" : "\u2264";
+    result = result.concat(`${idx > 0 ? " " : ""}`, obj.cmc_min !== obj.cmc_max ? `[${obj.cmc_min}${unit} ${cmc_min_closed} ${symbol} ${cmc_max_closed} ${obj.cmc_max}${unit} \xB1 ${obj.cmc_uncertainty}]` : `[${obj.cmc_min}${unit} \xB1 ${obj.cmc_uncertainty}]`);
+  });
+  return result;
+}
+function UncertaintyFormatter(props) {
+  const {
+    obProps,
+    fieldValue,
+    fieldSymbol,
+    fieldUnit,
+    Component = WrapperComponent
+  } = props;
+  return /* @__PURE__ */ jsx(Component, {
+    children: getUncertaintyFormat(obProps, fieldValue, fieldSymbol, fieldUnit)
+  });
+}
+export {
+  UncertaintyFormatter as U,
+  getUncertaintyFormat as g
+};

package/components/formatters/UncertaintyFormatter/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { UncertaintyFormatterProps } from './types';
+export declare function getUncertaintyFormat(obProps: any, fieldValue: string, fieldSymbol: string, fieldUnit: string): string;
+export declare function UncertaintyFormatter(props: UncertaintyFormatterProps): JSX.Element;

package/components/formatters/UncertaintyFormatter/types.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export interface UncertaintyRange {
+    cmc_min_closed: boolean;
+    cmc_min: number;
+    cmc_max_closed: boolean;
+    cmc_max: number;
+    cmc_uncertainty: number;
+}
+export interface UncertaintyFormatterProps {
+    Component?: React.ElementType;
+    obProps: any;
+    fieldValue: string;
+    fieldSymbol: string;
+    fieldUnit: string;
+}

package/components/formatters/dicctionary.d.ts

@@ -0,0 +1,3 @@
+import { Dictionary } from '@m4l/core';
+export declare function getFormattersComponentsDictionary(): string[];
+export declare const defaultFormattersDictionary: Dictionary;

package/components/formatters/index.0b5f95d0.js

@@ -0,0 +1,21 @@
+import "react";
+import "@m4l/core";
+import "../Icon/index.8d754623.js";
+import "@mui/material/styles";
+import "react/jsx-runtime";
+import "@m4l/graphics";
+function getFormattersComponentsDictionary() {
+  return ["formatters"];
+}
+const defaultFormattersDictionary = {
+  pager: {
+    boolean_yes: "Yes",
+    boolean_no: "No",
+    boolean_true: "True",
+    boolean_false: "False"
+  }
+};
+export {
+  defaultFormattersDictionary as d,
+  getFormattersComponentsDictionary as g
+};

package/components/formatters/index.d.ts

@@ -0,0 +1,6 @@
+export { BooleanFormatter } from './BooleanFormatter';
+export { DateFormatter } from './DateFormatter';
+export { UncertaintyFormatter, getUncertaintyFormat } from './UncertaintyFormatter';
+export { PointsFormatter, getFormatPoints } from './PointsFormatter';
+export { PriceFormatter, getFormatPrice } from './PriceFormatter';
+export type { UncertaintyRange } from './UncertaintyFormatter/types';

package/components/formatters/types.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from 'react';
+export declare type ComponentForrmaterType = 'div' | 'span' | ((props: PropsWithChildren<any>) => JSX.Element);

package/components/hook-form/RHFAutocomplete/dictionary.d.ts

@@ -0,0 +1,3 @@
+import { Dictionary } from '@m4l/core';
+export declare function getRHFAutocompleteComponentsDictionary(): string[];
+export declare const defaultRHFAutocompleteDictionary: Dictionary;

package/components/hook-form/RHFAutocomplete/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { RHFAutocompleteProps } from './types';
+export declare function RHFAutocomplete<T>(props: RHFAutocompleteProps<T>): JSX.Element;