@gridsuite/commons-ui 0.213.0 → 0.215.0

package/dist/components/composite/flatParameters/FlatParameters.js

@@ -0,0 +1,366 @@
+import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import { useState, useCallback, Fragment, createElement } from "react";
+import { List, ListItem, Typography, Divider, Select, MenuItem, TextField, IconButton, Autocomplete, Chip, Switch } from "@mui/material";
+import { Tune } from "@mui/icons-material";
+import { useIntl, FormattedMessage } from "react-intl";
+import { CustomTooltip } from "../../ui/tooltip/CustomTooltip.js";
+import { MultipleSelectionDialog } from "../../ui/dialogs/multipleSelectionDialog/MultipleSelectionDialog.js";
+const styles = {
+  paramList: {
+    width: "100%",
+    margin: 0
+  },
+  paramListItem: (theme) => ({
+    display: "flex",
+    justifyContent: "space-between",
+    gap: theme.spacing(2),
+    paddingLeft: 0,
+    paddingRight: 0
+  }),
+  paramName: {
+    fontWeight: "bold",
+    minWidth: "30%",
+    overflowWrap: "anywhere"
+  }
+};
+const FloatRE = /^-?\d*[.,]?\d*([eE]-?\d*)?$/;
+const IntegerRE = /^-?\d*$/;
+const ListRE = /^\[(.*)]$/;
+const sepRE = /[, ]/;
+function extractDefault(paramDescription) {
+  const d = paramDescription.defaultValue;
+  if (paramDescription.type === "BOOLEAN") {
+    return !!d;
+  }
+  if (paramDescription.type === "DOUBLE") {
+    return d - 0;
+  }
+  if (paramDescription.type === "INTEGER") {
+    return d - 0;
+  }
+  if (paramDescription.type === "STRING_LIST") {
+    if (Array.isArray(d)) {
+      return d;
+    }
+    const mo = ListRE.exec(d);
+    if (mo === null || mo.length <= 1) {
+      return [];
+    }
+    return mo[1].split(sepRE).map((s) => s.trim()).filter((s) => !!s);
+  }
+  return d ?? null;
+}
+function longestCommonPrefix(stringList) {
+  if (!stringList?.length) {
+    return "";
+  }
+  let prefix = stringList.reduce((acc, str) => str.length < acc.length ? str : acc);
+  stringList.forEach((str) => {
+    while (!str.startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+  });
+  return prefix;
+}
+function FlatParameters({
+  paramsAsArray,
+  initValues,
+  onChange,
+  variant = "outlined",
+  showSeparator = false,
+  selectionWithDialog = () => false
+}) {
+  const intl = useIntl();
+  const longestPrefix = longestCommonPrefix(paramsAsArray.map((m) => m.name));
+  const lastDotIndex = longestPrefix.lastIndexOf(".");
+  const prefix = longestPrefix.slice(0, lastDotIndex + 1);
+  const [uncommitted, setUncommitted] = useState(null);
+  const [inEditionParam, setInEditionParam] = useState(null);
+  const [openSelector, setOpenSelector] = useState(false);
+  const getTranslatedValue = useCallback(
+    (prefixValue, value) => {
+      return intl.formatMessage({
+        id: `${prefixValue}.${value}`,
+        defaultMessage: value
+      });
+    },
+    [intl]
+  );
+  const getSelectionDialogName = useCallback(
+    (paramName) => {
+      const defaultMessage = intl.formatMessage({
+        id: paramName,
+        defaultMessage: paramName.slice(prefix.length)
+      });
+      return intl.formatMessage({
+        id: `${paramName}.selectionDialog.name`,
+        defaultMessage
+      });
+    },
+    [intl, prefix.length]
+  );
+  const sortPossibleValues = useCallback(
+    (prefixValue, values) => {
+      if (values == null) {
+        return [];
+      }
+      return values.map((value) => {
+        return {
+          id: value,
+          message: getTranslatedValue(prefixValue, value)
+        };
+      }).sort((a, b) => a.message.localeCompare(b.message));
+    },
+    [getTranslatedValue]
+  );
+  const onFieldChange = useCallback(
+    (value, param) => {
+      const paramName = param.name;
+      const isInEdition = inEditionParam === paramName;
+      if (isInEdition) {
+        setUncommitted(value);
+      }
+      if (onChange) {
+        if (param.type === "STRING_LIST") {
+          onChange(paramName, value ? value.toString() : null, isInEdition);
+        } else {
+          onChange(paramName, value, isInEdition);
+        }
+      }
+    },
+    [inEditionParam, onChange]
+  );
+  const onUncommitted = useCallback(
+    (param, inEdit) => {
+      if (inEdit) {
+        setInEditionParam(param.name);
+      } else {
+        if (onChange && uncommitted != null) {
+          if (!["INTEGER", "DOUBLE"].includes(param.type)) {
+            onChange(param.name, uncommitted, false);
+          } else if (uncommitted) {
+            onChange(param.name, uncommitted - 0, false);
+          } else {
+            onChange(param.name, extractDefault(param), false);
+          }
+        }
+        setInEditionParam(null);
+        setUncommitted(null);
+      }
+    },
+    [uncommitted, onChange]
+  );
+  function mixInitAndDefault(param) {
+    if (param.name === inEditionParam && uncommitted !== null) {
+      return uncommitted;
+    }
+    if (initValues && Object.hasOwn(initValues, param.name)) {
+      if (param.type === "BOOLEAN") {
+        return initValues[param.name] === "false" ? false : initValues[param.name];
+      }
+      if (param.type !== "STRING_LIST") {
+        return initValues[param.name];
+      }
+      const valueList = initValues[param.name];
+      if (Array.isArray(valueList)) {
+        return valueList;
+      }
+      return valueList ? valueList.split(",").map((s) => s.trim()).filter((s) => !!s) : [];
+    }
+    return extractDefault(param);
+  }
+  const outputTransformFloatString = (value) => {
+    return value?.replace(",", ".") || "";
+  };
+  const getStringListValue = (allValues, selectValues) => {
+    if (!selectValues || !selectValues.length) {
+      return intl.formatMessage({ id: "flat_parameters/none" });
+    }
+    if (selectValues.length === allValues.length) {
+      return intl.formatMessage({ id: "flat_parameters/all" });
+    }
+    return intl.formatMessage({ id: "flat_parameters/some" });
+  };
+  const renderField = (param) => {
+    const fieldValue = mixInitAndDefault(param);
+    switch (param.type) {
+      case "BOOLEAN":
+        return /* @__PURE__ */ jsx(Switch, { checked: !!fieldValue, onChange: (e) => onFieldChange(e.target.checked, param) });
+      case "DOUBLE": {
+        const err = Number.isNaN(fieldValue) || typeof fieldValue !== "number" && !!fieldValue && Number.isNaN(fieldValue - 0);
+        return /* @__PURE__ */ jsx(
+          TextField,
+          {
+            size: "small",
+            sx: { width: "50%" },
+            inputProps: { style: { textAlign: "right" } },
+            value: fieldValue,
+            onFocus: () => onUncommitted(param, true),
+            onBlur: () => onUncommitted(param, false),
+            onChange: (e) => {
+              const m = FloatRE.exec(e.target.value);
+              if (m) {
+                onFieldChange(outputTransformFloatString(e.target.value), param);
+              }
+            },
+            error: err,
+            variant
+          }
+        );
+      }
+      case "INTEGER":
+        return /* @__PURE__ */ jsx(
+          TextField,
+          {
+            size: "small",
+            sx: { width: "50%" },
+            inputProps: { style: { textAlign: "right" } },
+            value: fieldValue,
+            onFocus: () => onUncommitted(param, true),
+            onBlur: () => onUncommitted(param, false),
+            onChange: (e) => {
+              const m = IntegerRE.exec(e.target.value);
+              if (m) {
+                onFieldChange(e.target.value, param);
+              }
+            },
+            variant
+          }
+        );
+      case "STRING_LIST":
+        if (param.possibleValues) {
+          const allOptions = sortPossibleValues(param.name, param.possibleValues).map(({ id }) => id);
+          const withDialog = selectionWithDialog(param);
+          if (withDialog) {
+            return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+              /* @__PURE__ */ jsx(
+                TextField,
+                {
+                  value: getStringListValue(allOptions, fieldValue),
+                  size: "small",
+                  variant,
+                  InputProps: {
+                    readOnly: true,
+                    endAdornment: /* @__PURE__ */ jsx(IconButton, { onClick: () => setOpenSelector(true), children: /* @__PURE__ */ jsx(Tune, {}) })
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                MultipleSelectionDialog,
+                {
+                  items: allOptions,
+                  titleId: getSelectionDialogName(param.name),
+                  open: openSelector,
+                  getItemLabel: (option) => getTranslatedValue(param.name, option),
+                  getItemId: (o) => o,
+                  selectedItems: fieldValue,
+                  addSelectAllCheckbox: true,
+                  handleClose: () => setOpenSelector(false),
+                  handleValidate: (selectedOptions) => {
+                    onFieldChange(selectedOptions, param);
+                    setOpenSelector(false);
+                  }
+                }
+              )
+            ] });
+          }
+          return /* @__PURE__ */ jsx(
+            Autocomplete,
+            {
+              fullWidth: true,
+              multiple: true,
+              size: "small",
+              options: sortPossibleValues(param.name, param.possibleValues).map((v) => v.id),
+              getOptionLabel: (option) => getTranslatedValue(param.name, option),
+              onChange: (e, value) => onFieldChange(value, param),
+              value: fieldValue,
+              renderTags: (values, getTagProps) => {
+                return values.map((value, index) => /* @__PURE__ */ createElement(
+                  Chip,
+                  {
+                    label: getTranslatedValue(param.name, value),
+                    ...getTagProps({ index }),
+                    key: `chip_${value}`
+                  }
+                ));
+              },
+              renderInput: (inputProps) => /* @__PURE__ */ jsx(TextField, { ...inputProps, variant })
+            }
+          );
+        }
+        return /* @__PURE__ */ jsx(
+          Autocomplete,
+          {
+            multiple: true,
+            freeSolo: true,
+            autoSelect: true,
+            sx: { width: "50%" },
+            options: [],
+            size: "small",
+            onChange: (e, value) => onFieldChange(value, param),
+            value: fieldValue,
+            renderTags: (values, getTagProps) => {
+              return values.map((value, index) => /* @__PURE__ */ createElement(
+                Chip,
+                {
+                  id: `chip_${value}`,
+                  size: "small",
+                  label: value,
+                  ...getTagProps({ index }),
+                  key: `chip_${value}`
+                }
+              ));
+            },
+            renderInput: (inputProps) => /* @__PURE__ */ jsx(TextField, { ...inputProps, variant })
+          }
+        );
+      case "STRING":
+        if (param.possibleValues) {
+          return /* @__PURE__ */ jsx(
+            Select,
+            {
+              labelId: param.name,
+              value: fieldValue ?? "",
+              onChange: (ev) => {
+                onFieldChange(ev.target.value, param);
+              },
+              size: "small",
+              sx: { minWidth: "4em" },
+              variant,
+              children: sortPossibleValues(param.name, param.possibleValues).map((value) => /* @__PURE__ */ jsx(MenuItem, { value: value.id, children: /* @__PURE__ */ jsx(Typography, { children: value.message }) }, value.id))
+            }
+          );
+        }
+    }
+    return /* @__PURE__ */ jsx(
+      TextField,
+      {
+        sx: { width: "50%" },
+        size: "small",
+        value: fieldValue || "",
+        onFocus: () => onUncommitted(param, true),
+        onBlur: () => onUncommitted(param, false),
+        onChange: (e) => onFieldChange(e.target.value, param),
+        variant
+      }
+    );
+  };
+  return /* @__PURE__ */ jsx(List, { sx: styles.paramList, children: paramsAsArray.map((param, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(ListItem, { sx: styles.paramListItem, children: [
+      /* @__PURE__ */ jsx(
+        CustomTooltip,
+        {
+          title: /* @__PURE__ */ jsx(FormattedMessage, { id: `${param.name}.desc`, defaultMessage: param.description }),
+          children: /* @__PURE__ */ jsx(Typography, { sx: styles.paramName, children: /* @__PURE__ */ jsx(FormattedMessage, { id: param.name, defaultMessage: param.name.slice(prefix.length) }) })
+        },
+        param.name
+      ),
+      renderField(param)
+    ] }),
+    showSeparator && index !== paramsAsArray.length - 1 && /* @__PURE__ */ jsx(Divider, {})
+  ] }, param.name)) });
+}
+export {
+  FlatParameters,
+  extractDefault
+};

package/dist/components/composite/grid/grid-item.js

@@ -0,0 +1,9 @@
+import { jsx } from "react/jsx-runtime";
+import { Grid } from "@mui/material";
+import { CustomTooltip } from "../../ui/tooltip/CustomTooltip.js";
+function GridItem({ children, size = 6, alignItem = "flex-start", tooltip }) {
+  return /* @__PURE__ */ jsx(Grid, { item: true, xs: size, alignItems: alignItem, children: children && (tooltip ? /* @__PURE__ */ jsx(CustomTooltip, { title: tooltip, children: /* @__PURE__ */ jsx("div", { children }) }) : children) });
+}
+export {
+  GridItem as default
+};

package/dist/components/composite/grid/grid-section.d.ts

@@ -0,0 +1,8 @@
+import { SxStyle } from '../../../utils/styles';
+export interface GridSectionProps {
+    title: string;
+    heading?: 1 | 2 | 3 | 4 | 5 | 6;
+    size?: number;
+    customStyle?: SxStyle;
+}
+export default function GridSection({ title, heading, size, customStyle }: Readonly<GridSectionProps>): import("react/jsx-runtime").JSX.Element;

package/dist/components/composite/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2024, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export * from './dnd-table';
+export * from './elementSearch';
+export * from './flatParameters';
+export * from './filter';
+export * from './grid';
+export * from './muiTable';
+export * from './reactQueryBuilder';
+export * from './agGridTable';
+export * from './customAGGrid';

package/dist/components/composite/index.js

@@ -0,0 +1,146 @@
+import { DndTable } from "./dnd-table-v2/dnd-table.js";
+import { DndColumnType, MAX_ROWS_NUMBER, SELECTED } from "./dnd-table-v2/dnd-table.type.js";
+import { getDefaultRowData } from "./dnd-table-v2/dnd-table-utils.js";
+import { DndTableAddRowsDialog } from "./dnd-table-v2/dnd-table-add-rows-dialog.js";
+import { DndTableBottomLeftButtons } from "./dnd-table-v2/dnd-table-bottom-left-buttons.js";
+import { DndTableBottomRightButtons } from "./dnd-table-v2/dnd-table-bottom-right-buttons.js";
+import { EquipmentItem } from "./elementSearch/elementItem/EquipmentItem.js";
+import { ElementSearchDialog } from "./elementSearch/elementSearchDialog/ElementSearchDialog.js";
+import { ElementSearchInput } from "./elementSearch/elementSearchInput/ElementSearchInput.js";
+import { useElementSearch } from "./elementSearch/hooks/useElementSearch.js";
+import { TagRenderer } from "./elementSearch/tagRenderer/TagRenderer.js";
+import { FlatParameters, extractDefault } from "./flatParameters/FlatParameters.js";
+import { FilterCreationDialog } from "./filter/FilterCreationDialog.js";
+import { FilterForm } from "./filter/FilterForm.js";
+import { DISTRIBUTION_KEY, FilterType } from "./filter/constants/FilterConstants.js";
+import { ExpertFilterEditionDialog } from "./filter/expert/ExpertFilterEditionDialog.js";
+import { ExpertFilterForm, expertFilterSchema, getExpertFilterEmptyFormData } from "./filter/expert/ExpertFilterForm.js";
+import { CombinatorType, DataType, OperatorType } from "./filter/expert/expertFilter.type.js";
+import { COMBINATOR_OPTIONS, CONVERTERS_MODE_OPTIONS, ENERGY_SOURCE_OPTIONS, EXPERT_FILTER_EQUIPMENTS, EXPERT_FILTER_FIELDS, EXPERT_FILTER_QUERY, FIELDS_OPTIONS, LOAD_TYPE_OPTIONS, OPERATOR_OPTIONS, PHASE_REGULATION_MODE_OPTIONS, RATIO_REGULATION_MODE_OPTIONS, REGULATION_TYPE_OPTIONS, RULES, SHUNT_COMPENSATOR_TYPE_OPTIONS, SVAR_REGULATION_MODE_OPTIONS } from "./filter/expert/expertFilterConstants.js";
+import { countRules, exportExpertRules, getNumberOfSiblings, getOperators, importExpertRules, queryValidator, recursiveRemove, testQuery } from "./filter/expert/expertFilterUtils.js";
+import { ExplicitNamingFilterEditionDialog } from "./filter/explicitNaming/ExplicitNamingFilterEditionDialog.js";
+import { ExplicitNamingFilterForm, explicitNamingFilterSchema, getExplicitNamingFilterEmptyFormData } from "./filter/explicitNaming/ExplicitNamingFilterForm.js";
+import { FILTER_EQUIPMENTS_ATTRIBUTES } from "./filter/explicitNaming/ExplicitNamingFilterConstants.js";
+import { saveExpertFilter, saveExplicitNamingFilter } from "./filter/utils/filterApi.js";
+import { CONTINGENCY_LIST_EQUIPMENTS, FILTER_EQUIPMENTS } from "./filter/utils/filterFormUtils.js";
+import "react/jsx-runtime";
+import "@mui/material";
+import "react-intl";
+import { OverflowableTableCell } from "./muiTable/OverflowableTableCell.js";
+import { OverflowableTableCellWithCheckbox } from "./muiTable/OverflowableTableCellWithCheckbox.js";
+import { AutocompleteWithFavorites } from "./reactQueryBuilder/AutocompleteWithFavorites.js";
+import { CombinatorSelector } from "./reactQueryBuilder/CombinatorSelector.js";
+import { CountryValueEditor } from "./reactQueryBuilder/CountryValueEditor.js";
+import { CustomReactQueryBuilder } from "./reactQueryBuilder/CustomReactQueryBuilder.js";
+import { ElementValueEditor } from "./reactQueryBuilder/ElementValueEditor.js";
+import { PropertyValueEditor } from "./reactQueryBuilder/PropertyValueEditor.js";
+import { RemoveButton } from "./reactQueryBuilder/RemoveButton.js";
+import { TextValueEditor } from "./reactQueryBuilder/TextValueEditor.js";
+import { TranslatedValueEditor } from "./reactQueryBuilder/TranslatedValueEditor.js";
+import { ValueEditor } from "./reactQueryBuilder/ValueEditor.js";
+import { ValueSelector } from "./reactQueryBuilder/ValueSelector.js";
+import { GroupValueEditor } from "./reactQueryBuilder/compositeRuleEditor/GroupValueEditor.js";
+import { RuleValueEditor } from "./reactQueryBuilder/compositeRuleEditor/RuleValueEditor.js";
+import { useConvertValue } from "./reactQueryBuilder/hooks/useConvertValue.js";
+import { useValid } from "./reactQueryBuilder/hooks/useValid.js";
+import { BottomRightButtons } from "./agGridTable/BottomRightButtons.js";
+import { CustomAgGridTable } from "./agGridTable/CustomAgGridTable.js";
+import { NumericEditor } from "./agGridTable/cellEditors/numericEditor.js";
+import { CsvUploader } from "./agGridTable/csvUploader/CsvUploader.js";
+import { CUSTOM_AGGRID_THEME, styles } from "./customAGGrid/customAggrid.style.js";
+import { CustomAGGrid } from "./customAGGrid/customAggrid.js";
+import { SeparatorCellRenderer } from "./customAGGrid/separatorCellRenderer.js";
+import { BooleanCellRenderer, BooleanNullableCellRenderer, ContingencyCellRenderer, DefaultCellRenderer, ErrorCellRenderer, MessageLogCellRenderer, NetworkModificationNameCellRenderer, NumericCellRenderer } from "./customAGGrid/cell-renderers.js";
+export {
+  AutocompleteWithFavorites,
+  BooleanCellRenderer,
+  BooleanNullableCellRenderer,
+  BottomRightButtons,
+  COMBINATOR_OPTIONS,
+  CONTINGENCY_LIST_EQUIPMENTS,
+  CONVERTERS_MODE_OPTIONS,
+  CUSTOM_AGGRID_THEME,
+  CombinatorSelector,
+  CombinatorType,
+  ContingencyCellRenderer,
+  CountryValueEditor,
+  CsvUploader,
+  CustomAGGrid,
+  CustomAgGridTable,
+  CustomReactQueryBuilder,
+  DISTRIBUTION_KEY,
+  DataType,
+  DefaultCellRenderer,
+  DndColumnType,
+  DndTable,
+  DndTableAddRowsDialog,
+  DndTableBottomLeftButtons,
+  DndTableBottomRightButtons,
+  ENERGY_SOURCE_OPTIONS,
+  EXPERT_FILTER_EQUIPMENTS,
+  EXPERT_FILTER_FIELDS,
+  EXPERT_FILTER_QUERY,
+  ElementSearchDialog,
+  ElementSearchInput,
+  ElementValueEditor,
+  EquipmentItem,
+  ErrorCellRenderer,
+  ExpertFilterEditionDialog,
+  ExpertFilterForm,
+  ExplicitNamingFilterEditionDialog,
+  ExplicitNamingFilterForm,
+  FIELDS_OPTIONS,
+  FILTER_EQUIPMENTS,
+  FILTER_EQUIPMENTS_ATTRIBUTES,
+  FilterCreationDialog,
+  FilterForm,
+  FilterType,
+  FlatParameters,
+  GroupValueEditor,
+  LOAD_TYPE_OPTIONS,
+  MAX_ROWS_NUMBER,
+  MessageLogCellRenderer,
+  NetworkModificationNameCellRenderer,
+  NumericCellRenderer,
+  NumericEditor,
+  OPERATOR_OPTIONS,
+  OperatorType,
+  OverflowableTableCell,
+  OverflowableTableCellWithCheckbox,
+  PHASE_REGULATION_MODE_OPTIONS,
+  PropertyValueEditor,
+  RATIO_REGULATION_MODE_OPTIONS,
+  REGULATION_TYPE_OPTIONS,
+  RULES,
+  RemoveButton,
+  RuleValueEditor,
+  SELECTED,
+  SHUNT_COMPENSATOR_TYPE_OPTIONS,
+  SVAR_REGULATION_MODE_OPTIONS,
+  SeparatorCellRenderer,
+  TagRenderer,
+  TextValueEditor,
+  TranslatedValueEditor,
+  ValueEditor,
+  ValueSelector,
+  countRules,
+  expertFilterSchema,
+  explicitNamingFilterSchema,
+  exportExpertRules,
+  extractDefault,
+  getDefaultRowData,
+  getExpertFilterEmptyFormData,
+  getExplicitNamingFilterEmptyFormData,
+  getNumberOfSiblings,
+  getOperators,
+  importExpertRules,
+  queryValidator,
+  recursiveRemove,
+  saveExpertFilter,
+  saveExplicitNamingFilter,
+  styles,
+  testQuery,
+  useConvertValue,
+  useElementSearch,
+  useValid
+};

package/dist/components/composite/muiTable/OverflowableTableCell.d.ts

@@ -0,0 +1,3 @@
+import { OverflowableTextProps } from '../../ui/overflowableText';
+export declare function OverflowableTableCell(overflowableTextProps: Readonly<OverflowableTextProps>): import("react/jsx-runtime").JSX.Element;
+export default OverflowableTableCell;

package/dist/components/composite/muiTable/OverflowableTableCell.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { TableCell } from "@mui/material";
+import { OverflowableText } from "../../ui/overflowableText/OverflowableText.js";
+function OverflowableTableCell(overflowableTextProps) {
+  return /* @__PURE__ */ jsx(TableCell, { sx: { display: "flex", alignItems: "center" }, children: /* @__PURE__ */ jsx(OverflowableText, { sx: { flex: "1 1 0", width: 0, display: "block" }, ...overflowableTextProps }) });
+}
+export {
+  OverflowableTableCell,
+  OverflowableTableCell as default
+};

package/dist/components/composite/muiTable/OverflowableTableCellWithCheckbox.d.ts

@@ -0,0 +1,6 @@
+import { OverflowableTextProps } from '../../ui/overflowableText';
+export interface OverflowableTableCellProps extends OverflowableTextProps {
+    checked: boolean;
+}
+export declare function OverflowableTableCellWithCheckbox({ checked, ...overflowableTextProps }: Readonly<OverflowableTableCellProps>): import("react/jsx-runtime").JSX.Element;
+export default OverflowableTableCellWithCheckbox;

package/dist/components/composite/muiTable/OverflowableTableCellWithCheckbox.js

@@ -0,0 +1,16 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { TableCell, Checkbox } from "@mui/material";
+import { OverflowableText } from "../../ui/overflowableText/OverflowableText.js";
+function OverflowableTableCellWithCheckbox({
+  checked,
+  ...overflowableTextProps
+}) {
+  return /* @__PURE__ */ jsxs(TableCell, { padding: "checkbox", sx: { display: "flex", alignItems: "center", width: "100%" }, children: [
+    /* @__PURE__ */ jsx(Checkbox, { checked }),
+    /* @__PURE__ */ jsx(OverflowableText, { sx: { flex: "1 1 0", width: 0, display: "block" }, ...overflowableTextProps })
+  ] });
+}
+export {
+  OverflowableTableCellWithCheckbox,
+  OverflowableTableCellWithCheckbox as default
+};

package/dist/components/composite/reactQueryBuilder/CombinatorSelector.js

@@ -0,0 +1,40 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { MaterialValueSelector } from "@react-querybuilder/material";
+import { PopupConfirmationDialog } from "../../ui/dialogs/popupConfirmationDialog/PopupConfirmationDialog.js";
+import { useSelectAppearance } from "../../../hooks/useSelectAppearance.js";
+function CombinatorSelector(props) {
+  const { options, value, handleOnChange } = props;
+  const [tempCombinator, setTempCombinator] = useState(value);
+  const [openPopup, setOpenPopup] = useState(false);
+  const handlePopupConfirmation = useCallback(() => {
+    handleOnChange(tempCombinator);
+    setOpenPopup(false);
+  }, [handleOnChange, tempCombinator]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      PopupConfirmationDialog,
+      {
+        message: "changeOperatorMessage",
+        validateButtonLabel: "button.changeOperator",
+        openConfirmationPopup: openPopup,
+        setOpenConfirmationPopup: setOpenPopup,
+        handlePopupConfirmation
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MaterialValueSelector,
+      {
+        ...props,
+        handleOnChange: (newCombinator) => {
+          setTempCombinator(newCombinator);
+          setOpenPopup(true);
+        },
+        ...useSelectAppearance(options.length)
+      }
+    )
+  ] });
+}
+export {
+  CombinatorSelector
+};

package/dist/components/composite/reactQueryBuilder/CountryValueEditor.js

@@ -0,0 +1,50 @@
+import { jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { useLocalizedCountries } from "../../../hooks/useLocalizedCountries.js";
+import { useCustomFormContext } from "../../ui/reactHookForm/provider/useCustomFormContext.js";
+import { fetchFavoriteAndDefaultCountries } from "../../../services/appsMetadata.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "@mui/icons-material";
+import "../../../utils/yupConfig.js";
+import { AutocompleteWithFavorites } from "./AutocompleteWithFavorites.js";
+import { useConvertValue } from "./hooks/useConvertValue.js";
+import { useValid } from "./hooks/useValid.js";
+function CountryValueEditor(props) {
+  const { value, handleOnChange, title } = props;
+  const { language } = useCustomFormContext();
+  const { translate, countryCodes } = useLocalizedCountries(language);
+  const [favoriteCountryCodes, setFavoriteCountryCodes] = useState([]);
+  const [initialized, setInitialized] = useState(false);
+  useEffect(() => {
+    if (!initialized) {
+      fetchFavoriteAndDefaultCountries().then(({ favoriteCountries, defaultCountry }) => {
+        setFavoriteCountryCodes(favoriteCountries);
+        if (defaultCountry && !value) {
+          handleOnChange(defaultCountry);
+        }
+        setInitialized(true);
+      });
+    }
+  }, [initialized, setInitialized, handleOnChange, value]);
+  useConvertValue(props);
+  const valid = useValid(props);
+  return /* @__PURE__ */ jsx(
+    AutocompleteWithFavorites,
+    {
+      value,
+      options: countryCodes,
+      favorites: favoriteCountryCodes,
+      getOptionLabel: (code) => code ? translate(code) : "",
+      valid,
+      title,
+      onChange: (event, newValue) => {
+        handleOnChange(newValue);
+      },
+      fullWidth: true
+    }
+  );
+}
+export {
+  CountryValueEditor
+};