@gridsuite/commons-ui 0.280.0 → 0.282.0

package/dist/features/network-modifications/tabular/tabular.types.d.ts

@@ -0,0 +1,41 @@
+import { UUID } from 'node:crypto';
+import { EquipmentType, ModificationType, PredefinedProperties } from '../../../utils';
+import { TabularProperty } from './properties/tabularProperty.utils';
+export declare enum TabularModificationType {
+    CREATION = "creation",
+    MODIFICATION = "modification"
+}
+export interface TabularModificationRow {
+    [key: string]: any;
+}
+export interface TabularField {
+    id: string;
+    name?: string;
+    index?: number;
+    type?: string;
+    options?: string[];
+    required?: boolean;
+    requiredIf?: {
+        id: string;
+    };
+}
+export type TabularFields = Partial<Record<EquipmentType, TabularField[]>>;
+export type TabularModificationDto = {
+    uuid: UUID;
+    type: ModificationType.TABULAR_MODIFICATION | ModificationType.TABULAR_CREATION;
+    properties: TabularProperty[];
+    csvFilename: string;
+    modificationType: ModificationType;
+    modifications: TabularModificationRow[];
+};
+/** Payload sent to the back-end for a tabular creation or modification. */
+export type TabularFormDto = {
+    type: ModificationType.TABULAR_MODIFICATION | ModificationType.TABULAR_CREATION;
+    modificationType: string;
+    modifications: TabularModificationRow[];
+    csvFilename?: string;
+    properties?: TabularProperty[];
+};
+export type PredefinedEquipmentProperties = {
+    [p: string]: PredefinedProperties;
+};

package/dist/features/network-modifications/tabular/tabular.types.js

@@ -0,0 +1,8 @@
+var TabularModificationType = /* @__PURE__ */ ((TabularModificationType2) => {
+  TabularModificationType2["CREATION"] = "creation";
+  TabularModificationType2["MODIFICATION"] = "modification";
+  return TabularModificationType2;
+})(TabularModificationType || {});
+export {
+  TabularModificationType
+};

package/dist/features/network-modifications/tabular/tabular.utils.d.ts

@@ -0,0 +1,68 @@
+import { IntlShape } from 'react-intl';
+import { Property, ReactiveCapabilityCurvePoints } from '../common';
+import { TabularFieldConstants } from './tabular.constants';
+import { TabularProperty } from './properties/tabularProperty.utils';
+import { TabularModificationType, PredefinedEquipmentProperties, TabularField, TabularModificationRow } from './tabular.types';
+import * as yup from 'yup';
+export declare const tabularFormSchema: yup.ObjectSchema<NonNullable<{
+    type: string;
+    modificationsTable: any[];
+    csvFilename: string | undefined;
+} & {
+    properties: {
+        name: string;
+        selected: NonNullable<boolean | undefined>;
+        predefined: NonNullable<boolean | undefined>;
+    }[] | undefined;
+}>, yup.AnyObject, {
+    type: undefined;
+    modificationsTable: undefined;
+    csvFilename: undefined;
+    properties: "";
+}, "">;
+export type TabularFormType = yup.InferType<typeof tabularFormSchema>;
+export declare const getEmptyTabularFormData: (equipmentType: string) => {
+    type: string;
+    modificationsTable: never[];
+    properties: never[];
+    csvFilename: undefined;
+};
+export declare const formatModification: (modification: TabularModificationRow) => {
+    [key: string]: any;
+};
+export declare const addPropertiesFromBack: (modification: TabularModificationRow, tabularProperties: Property[] | null) => TabularModificationRow;
+export declare const convertReactiveCapabilityCurvePointsFromBackToFront: (value: ReactiveCapabilityCurvePoints[]) => {
+    key: TabularFieldConstants;
+    value: number | null;
+}[];
+export declare const convertReactiveCapabilityCurvePointsFromFrontToBack: (modification: TabularModificationRow) => void;
+export declare const setFieldTypeError: (fieldTypeInError: string, expectedTypeForFieldInError: string, tableName: string, setError: (tableName: string, error: {
+    type: string;
+    message?: string;
+}) => void, intl: IntlShape, expectedValues?: string[]) => void;
+export declare const isFieldTypeOk: (value: any, fieldDefinition: {
+    type?: string;
+    options?: any[];
+} | undefined) => boolean;
+/**
+ * Sanitize a CSV cell value before injecting it into the table:
+ * - a mandatory boolean (checkbox) cell with no/invalid value defaults to `false`
+ *   (an empty checkbox cannot be distinguished from `false`),
+ * - any other value with a wrong format is dropped (replaced by `null`) so invalid data
+ *   is never injected,
+ * - otherwise the value is kept as-is (including non-typed `property_*` columns).
+ */
+export declare const sanitizeRowValue: (value: any, fieldDefinition: TabularField | undefined) => any;
+interface CommentLinesConfig {
+    fields: TabularField[] | null;
+    selectedProperties: string[];
+    intl: IntlShape;
+    equipmentType: string;
+    language: string;
+    formType: TabularModificationType;
+    predefinedEquipmentProperties?: PredefinedEquipmentProperties;
+}
+export declare const generateCommentLines: ({ fields, selectedProperties, intl, equipmentType, language, formType, predefinedEquipmentProperties, }: CommentLinesConfig) => string[][];
+export declare const transformProperties: (row: TabularModificationRow) => Property[];
+export declare const getSelectedTabularPropertyNames: (tabularProperties: TabularProperty[] | undefined) => string[];
+export {};

package/dist/features/network-modifications/tabular/tabular.utils.js

@@ -0,0 +1,301 @@
+import * as yup from "yup";
+import { FieldConstants } from "../../../utils/constants/fieldConstants.js";
+import { MODIFICATIONS_REQUIRED_TAB_ERROR } from "../../../utils/constants/translationKeys.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import { getCsvDelimiter } from "../../../utils/langs.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { equipmentTypesForPredefinedPropertiesMapper } from "../../../utils/mapper/equipmentTypesForPredefinedPropertiesMapper.js";
+import "react";
+import "react-hook-form";
+import { createPropertyModification } from "../common/properties/propertyUtils.js";
+import "@mui/material";
+import "react-intl";
+import "../../../components/ui/overflowableText/OverflowableText.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../../components/ui/reactHookForm/provider/CustomFormProvider.js";
+import "../../../components/ui/treeViewFinder/TreeViewFinder.js";
+import "../../../components/ui/reactHookForm/numbers/RangeInput.js";
+import "@material-symbols/svg-400/outlined/left_panel_open.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_output.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_input.svg?react";
+import "@material-symbols/svg-400/outlined/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes-fill.svg?react";
+import "../../../components/ui/dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../../components/ui/reactHookForm/expandableInput/ExpandableInput.js";
+import "../../../components/ui/reactHookForm/directory-item-input/directory-item-utils.js";
+import "@hello-pangea/dnd";
+import "../../../components/ui/dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "../../../components/ui/snackbarProvider/SnackbarProvider.js";
+import "mui-nested-menu";
+import "react-resizable-panels";
+import "react-papaparse";
+import "react-dom";
+import "autosuggest-highlight/match";
+import "autosuggest-highlight/parse";
+import "clsx";
+import "../../../components/composite/filter/FilterCreationDialog.js";
+import "../../../components/composite/filter/HeaderFilterForm.js";
+import "../../../components/composite/filter/explicitNaming/ExplicitNamingFilterForm.js";
+import "../../../components/composite/filter/expert/ExpertFilterForm.js";
+import "../../../components/composite/filter/expert/ExpertFilterEditionDialog.js";
+import "../../../components/composite/filter/expert/expertFilterConstants.js";
+import "react-querybuilder";
+import "uuid";
+import "../../../components/composite/filter/explicitNaming/ExplicitNamingFilterEditionDialog.js";
+import "../../../components/composite/filter/utils/filterFormUtils.js";
+import "@react-querybuilder/material";
+import "../../../components/composite/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "../../../components/composite/reactQueryBuilder/PropertyValueEditor.js";
+import "../../../components/composite/agGridTable/BottomTableButtons.js";
+import "../../../components/composite/agGridTable/CustomAgGridTable.js";
+import "ag-grid-community";
+import "../../../components/composite/customAGGrid/customAggrid.js";
+import "../../../components/composite/customAGGrid/context/custom-aggrid-context.js";
+import "mathjs";
+import "../../../components/composite/report/report-viewer/log-table/log-table.js";
+import "react-window";
+import "../../../components/composite/report/report-treeview/treeview-item.js";
+import "../../../components/composite/report/report-viewer/context/report-viewer-context.js";
+import "../common/regulatingTerminal/RegulatingTerminalForm.js";
+import "@mui/material/colors";
+import "@mui/x-charts";
+import "../common/currentLimits/limitsPane.utils.js";
+import { TabularFieldConstants, PROPERTY_CSV_COLUMN_PREFIX, TABULAR_ENUM, TABULAR_NUMBER, TABULAR_BOOLEAN } from "./tabular.constants.js";
+import { tabularPropertiesSchema } from "./properties/tabularProperty.utils.js";
+import { TabularModificationType } from "./tabular.types.js";
+const tabularFormSchema = yup.object().shape({
+  [FieldConstants.TYPE]: yup.string().nullable().required(),
+  [TabularFieldConstants.MODIFICATIONS_TABLE]: yup.array().min(1, MODIFICATIONS_REQUIRED_TAB_ERROR).required(),
+  [TabularFieldConstants.CSV_FILENAME]: yup.string()
+}).concat(tabularPropertiesSchema).required();
+const getEmptyTabularFormData = (equipmentType) => {
+  return {
+    [FieldConstants.TYPE]: equipmentType,
+    [TabularFieldConstants.MODIFICATIONS_TABLE]: [],
+    [TabularFieldConstants.TABULAR_PROPERTIES]: [],
+    [TabularFieldConstants.CSV_FILENAME]: void 0
+  };
+};
+const formatModification = (modification) => {
+  const { type, date, uuid, ...rest } = modification;
+  return rest;
+};
+const addPropertiesFromBack = (modification, tabularProperties) => {
+  const updatedModification = { ...modification };
+  tabularProperties?.forEach((property) => {
+    updatedModification[PROPERTY_CSV_COLUMN_PREFIX + property.name] = property.value;
+  });
+  return updatedModification;
+};
+const convertReactiveCapabilityCurvePointsFromBackToFront = (value) => {
+  const curvePoint1 = value[0];
+  const curvePoint2 = value[1];
+  const curvePoint3 = value[2];
+  if (!curvePoint1) {
+    return [];
+  }
+  const result = [
+    {
+      key: TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MIN,
+      value: curvePoint1.p
+    },
+    {
+      key: TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_MIN,
+      value: curvePoint1.maxQ
+    },
+    {
+      key: TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_MIN,
+      value: curvePoint1.minQ
+    }
+  ];
+  if (curvePoint2) {
+    const isLastPoint = !curvePoint3;
+    result.push(
+      {
+        key: isLastPoint ? TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MAX : TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_0,
+        value: curvePoint2.p
+      },
+      {
+        key: isLastPoint ? TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_MAX : TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_0,
+        value: curvePoint2.maxQ
+      },
+      {
+        key: isLastPoint ? TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_MAX : TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_0,
+        value: curvePoint2.minQ
+      }
+    );
+  }
+  if (curvePoint3) {
+    result.push(
+      { key: TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MAX, value: curvePoint3.p },
+      { key: TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_MAX, value: curvePoint3.maxQ },
+      { key: TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_MAX, value: curvePoint3.minQ }
+    );
+  }
+  return result;
+};
+const convertReactiveCapabilityCurvePointsFromFrontToBack = (modification) => {
+  if (modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE]) {
+    const rccPoints = [];
+    if (modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MIN] !== null) {
+      rccPoints.push({
+        p: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MIN],
+        maxQ: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_MIN],
+        minQ: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_MIN]
+      });
+    }
+    if (modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_0] !== null) {
+      rccPoints.push({
+        p: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_0],
+        maxQ: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_0],
+        minQ: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_0]
+      });
+    }
+    if (modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MAX] !== null) {
+      rccPoints.push({
+        p: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_P_MAX],
+        maxQ: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MAX_P_MAX],
+        minQ: modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_Q_MIN_P_MAX]
+      });
+    }
+    modification[TabularFieldConstants.REACTIVE_CAPABILITY_CURVE_POINTS] = rccPoints;
+  }
+};
+const setFieldTypeError = (fieldTypeInError, expectedTypeForFieldInError, tableName, setError, intl, expectedValues) => {
+  if (expectedTypeForFieldInError === TABULAR_ENUM) {
+    setError(tableName, {
+      type: "custom",
+      message: intl.formatMessage(
+        { id: "WrongEnumValue" },
+        {
+          field: fieldTypeInError,
+          expectedValues: expectedValues?.join(", ") ?? ""
+        }
+      )
+    });
+  } else {
+    setError(tableName, {
+      type: "custom",
+      message: intl.formatMessage(
+        { id: "WrongFieldType" },
+        {
+          field: fieldTypeInError,
+          type: intl.formatMessage({ id: `fieldType.${expectedTypeForFieldInError}` })
+        }
+      )
+    });
+  }
+};
+const isFieldTypeOk = (value, fieldDefinition) => {
+  if (!fieldDefinition?.type || value === null || value === void 0) {
+    return true;
+  }
+  switch (fieldDefinition.type) {
+    case TABULAR_BOOLEAN:
+      if (typeof value !== "boolean") {
+        return false;
+      }
+      break;
+    case TABULAR_NUMBER: {
+      const parsedNumber = Number.parseFloat(value);
+      if (Number.isNaN(parsedNumber)) {
+        return false;
+      }
+      break;
+    }
+    case TABULAR_ENUM:
+      if (!fieldDefinition?.options?.includes(value)) {
+        return false;
+      }
+      break;
+    default:
+      console.warn(`Unknown type "${fieldDefinition.type}" for value "${value}". Value will be returned as-is.`);
+      break;
+  }
+  return true;
+};
+const sanitizeRowValue = (value, fieldDefinition) => {
+  if (fieldDefinition?.type === TABULAR_BOOLEAN && fieldDefinition.required && typeof value !== "boolean") {
+    return false;
+  }
+  if (!isFieldTypeOk(value, fieldDefinition)) {
+    return null;
+  }
+  return value;
+};
+const appendPredefinedPropertyValues = (skeletonComment, predefinedProperties, selectedProperties, separator, columnCount) => {
+  let commentLine = skeletonComment.length === 0 ? separator.repeat(columnCount - 1 - selectedProperties.length) : skeletonComment;
+  selectedProperties.forEach((propertyName) => {
+    const possibleValues = predefinedProperties[propertyName]?.toSorted((a, b) => a.localeCompare(b)) ?? [];
+    commentLine += separator + possibleValues.join(" | ");
+  });
+  return commentLine;
+};
+const generateCommentLines = ({
+  fields,
+  selectedProperties,
+  intl,
+  equipmentType,
+  language,
+  formType,
+  predefinedEquipmentProperties
+}) => {
+  const csvTranslatedColumns = fields?.map((field) => intl.formatMessage({ id: field.id }) + (field.required ? " (*)" : ""))?.concat(selectedProperties);
+  if (!csvTranslatedColumns) {
+    return [];
+  }
+  const separator = getCsvDelimiter(language);
+  const commentData = [
+    csvTranslatedColumns.map((column, index) => index === 0 ? `#${column}` : column)
+  ];
+  const formTypeKeyPart = formType === TabularModificationType.CREATION ? "Creation" : "Modification";
+  const commentKey = `Tabular${formTypeKeyPart}SkeletonComment.${equipmentType}`;
+  let secondCommentLine = intl.messages[commentKey] ? intl.formatMessage({ id: commentKey }) : "";
+  const networkEquipmentType = equipmentTypesForPredefinedPropertiesMapper(equipmentType);
+  const predefinedProperties = networkEquipmentType ? predefinedEquipmentProperties?.[networkEquipmentType] : void 0;
+  if (selectedProperties.length && predefinedProperties) {
+    secondCommentLine = appendPredefinedPropertyValues(
+      secondCommentLine,
+      predefinedProperties,
+      selectedProperties,
+      separator,
+      csvTranslatedColumns.length
+    );
+  }
+  if (secondCommentLine.replaceAll(separator, "").length > 0) {
+    commentData.push(secondCommentLine.split(separator));
+  }
+  return commentData;
+};
+const transformProperties = (row) => {
+  const propertiesModifications = [];
+  Object.keys(row).forEach((key) => {
+    if (key.startsWith(PROPERTY_CSV_COLUMN_PREFIX) && row[key]?.length) {
+      propertiesModifications.push(
+        createPropertyModification(key.replace(PROPERTY_CSV_COLUMN_PREFIX, ""), row[key])
+      );
+      delete row[key];
+    }
+  });
+  return propertiesModifications;
+};
+const getSelectedTabularPropertyNames = (tabularProperties) => tabularProperties?.filter((property) => property.selected)?.map((property) => property.name) ?? [];
+export {
+  addPropertiesFromBack,
+  convertReactiveCapabilityCurvePointsFromBackToFront,
+  convertReactiveCapabilityCurvePointsFromFrontToBack,
+  formatModification,
+  generateCommentLines,
+  getEmptyTabularFormData,
+  getSelectedTabularPropertyNames,
+  isFieldTypeOk,
+  sanitizeRowValue,
+  setFieldTypeError,
+  tabularFormSchema,
+  transformProperties
+};

package/dist/features/network-modifications/tabular/tabularCreation.utils.d.ts

@@ -0,0 +1,25 @@
+import { TabularFieldConstants } from './tabular.constants';
+import { TabularFields, TabularFormDto, TabularModificationDto, TabularModificationRow } from './tabular.types';
+import { TabularFormType } from './tabular.utils';
+export declare const TABULAR_CREATION_FIELDS: TabularFields;
+export declare const TABULAR_CREATION_TYPES: {
+    [key: string]: string;
+};
+export declare const convertCreationFieldFromBackToFront: (key: string, value: any) => {
+    key: TabularFieldConstants;
+    value: number | null;
+}[] | {
+    key: string;
+    value: any;
+};
+export declare const convertCreationFieldFromFrontToBack: (key: string, value: string | number | boolean) => {
+    key: string;
+    value: string | number | boolean;
+};
+export declare const getEquipmentTypeFromCreationType: (type: string) => string | undefined;
+export declare const convertCreations: (creations: TabularModificationRow[]) => TabularModificationRow[];
+/** Convert a single form row into its back-end creation representation. */
+export declare const transformRowToBackEndCreation: (row: TabularModificationRow, modificationType: string) => TabularModificationRow;
+export declare const transformCreationsTable: (modificationType: string, creationsTable?: TabularModificationRow[]) => TabularModificationRow[];
+export declare const tabularCreationDtoToForm: (dto: TabularModificationDto) => TabularFormType;
+export declare const tabularCreationFormToDto: (form: TabularFormType) => TabularFormDto;