@gridsuite/commons-ui 0.55.0 → 0.57.0

package/dist/components/filter/expert/expert-filter-utils.d.ts

@@ -0,0 +1,91 @@
+import { DataType, RuleGroupTypeExport } from './expert-filter.type';
+import { IntlShape } from 'react-intl';
+import { QueryValidator, RuleGroupType, RuleGroupTypeAny } from 'react-querybuilder';
+
+type CustomRuleGroupType = RuleGroupType & {
+    dataType: DataType;
+};
+export declare const getOperators: (fieldName: string, intl: IntlShape) => {
+    name: string;
+    label: string;
+}[] | ({
+    readonly name: "=";
+    readonly value: "=";
+    readonly label: "=";
+} | {
+    readonly name: "!=";
+    readonly value: "!=";
+    readonly label: "!=";
+} | {
+    readonly name: "<";
+    readonly value: "<";
+    readonly label: "<";
+} | {
+    readonly name: ">";
+    readonly value: ">";
+    readonly label: ">";
+} | {
+    readonly name: "<=";
+    readonly value: "<=";
+    readonly label: "<=";
+} | {
+    readonly name: ">=";
+    readonly value: ">=";
+    readonly label: ">=";
+} | {
+    readonly name: "contains";
+    readonly value: "contains";
+    readonly label: "contains";
+} | {
+    readonly name: "beginsWith";
+    readonly value: "beginsWith";
+    readonly label: "begins with";
+} | {
+    readonly name: "endsWith";
+    readonly value: "endsWith";
+    readonly label: "ends with";
+} | {
+    readonly name: "doesNotContain";
+    readonly value: "doesNotContain";
+    readonly label: "does not contain";
+} | {
+    readonly name: "doesNotBeginWith";
+    readonly value: "doesNotBeginWith";
+    readonly label: "does not begin with";
+} | {
+    readonly name: "doesNotEndWith";
+    readonly value: "doesNotEndWith";
+    readonly label: "does not end with";
+} | {
+    readonly name: "null";
+    readonly value: "null";
+    readonly label: "is null";
+} | {
+    readonly name: "notNull";
+    readonly value: "notNull";
+    readonly label: "is not null";
+} | {
+    readonly name: "in";
+    readonly value: "in";
+    readonly label: "in";
+} | {
+    readonly name: "notIn";
+    readonly value: "notIn";
+    readonly label: "not in";
+} | {
+    readonly name: "between";
+    readonly value: "between";
+    readonly label: "between";
+} | {
+    readonly name: "notBetween";
+    readonly value: "notBetween";
+    readonly label: "not between";
+})[];
+export declare function exportExpertRules(query: CustomRuleGroupType): RuleGroupTypeExport;
+export declare function importExpertRules(query: RuleGroupTypeExport): CustomRuleGroupType;
+export declare function countRules(query: RuleGroupTypeAny): number;
+export declare const testQuery: (check: string, query: RuleGroupTypeAny) => boolean;
+export declare const queryValidator: QueryValidator;
+export declare function recursiveRemove(query: RuleGroupTypeAny, path: number[]): RuleGroupTypeAny;
+export declare function getNumberOfSiblings(path: number[], query: RuleGroupTypeAny): number;
+export {};

package/dist/components/filter/expert/expert-filter-utils.js

@@ -0,0 +1,304 @@
+import { defaultOperators, getParentPath, remove, findPath } from "react-querybuilder";
+import { FieldType, DataType, OperatorType } from "./expert-filter.type.js";
+import { validate } from "uuid";
+import { FIELDS_OPTIONS, OPERATOR_OPTIONS, RULES } from "../constants/expert-filter-constants.js";
+import { isBlankOrEmpty, microUnitToUnit, unitToMicroUnit } from "../../../utils/conversion-utils.js";
+const microUnits = [
+  FieldType.SHUNT_CONDUCTANCE_1,
+  FieldType.SHUNT_CONDUCTANCE_2,
+  FieldType.SHUNT_SUSCEPTANCE_1,
+  FieldType.SHUNT_SUSCEPTANCE_2
+];
+const getDataType = (fieldName, operator) => {
+  if ((fieldName === FieldType.ID || fieldName === FieldType.VOLTAGE_LEVEL_ID || fieldName === FieldType.VOLTAGE_LEVEL_ID_1 || fieldName === FieldType.VOLTAGE_LEVEL_ID_2) && (operator === OperatorType.IS_PART_OF || operator === OperatorType.IS_NOT_PART_OF)) {
+    return DataType.FILTER_UUID;
+  }
+  const field = Object.values(FIELDS_OPTIONS).find(
+    (field2) => field2.name === fieldName
+  );
+  return field == null ? void 0 : field.dataType;
+};
+const getOperators = (fieldName, intl) => {
+  const field = Object.values(FIELDS_OPTIONS).find(
+    (field2) => field2.name === fieldName
+  );
+  switch (field == null ? void 0 : field.dataType) {
+    case DataType.STRING:
+      let operators = [
+        OPERATOR_OPTIONS.CONTAINS,
+        OPERATOR_OPTIONS.IS,
+        OPERATOR_OPTIONS.BEGINS_WITH,
+        OPERATOR_OPTIONS.ENDS_WITH,
+        OPERATOR_OPTIONS.IN,
+        OPERATOR_OPTIONS.EXISTS,
+        OPERATOR_OPTIONS.NOT_EXISTS
+      ];
+      if (field.name === FieldType.ID || field.name === FieldType.VOLTAGE_LEVEL_ID || field.name === FieldType.VOLTAGE_LEVEL_ID_1 || field.name === FieldType.VOLTAGE_LEVEL_ID_2) {
+        operators.push(OPERATOR_OPTIONS.IS_PART_OF);
+        operators.push(OPERATOR_OPTIONS.IS_NOT_PART_OF);
+      }
+      if (field.name === FieldType.ID) {
+        operators = operators.filter(
+          (field2) => field2.name !== OperatorType.EXISTS && field2.name !== OperatorType.NOT_EXISTS
+        );
+      }
+      return operators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    case DataType.NUMBER:
+      return [
+        OPERATOR_OPTIONS.EQUALS,
+        OPERATOR_OPTIONS.GREATER,
+        OPERATOR_OPTIONS.GREATER_OR_EQUALS,
+        OPERATOR_OPTIONS.LOWER,
+        OPERATOR_OPTIONS.LOWER_OR_EQUALS,
+        OPERATOR_OPTIONS.BETWEEN,
+        OPERATOR_OPTIONS.EXISTS,
+        OPERATOR_OPTIONS.NOT_EXISTS
+      ].map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    case DataType.BOOLEAN:
+      return [OPERATOR_OPTIONS.EQUALS].map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    case DataType.ENUM:
+      let enumOperators = [
+        OPERATOR_OPTIONS.EQUALS,
+        OPERATOR_OPTIONS.NOT_EQUALS,
+        OPERATOR_OPTIONS.IN
+      ];
+      if (field.name === FieldType.SHUNT_COMPENSATOR_TYPE) {
+        enumOperators = enumOperators.filter(
+          (field2) => field2.customName !== OperatorType.IN
+        );
+      }
+      return enumOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+    case DataType.PROPERTY:
+      let propertiesOperators = [OPERATOR_OPTIONS.IS];
+      return propertiesOperators.map((operator) => ({
+        name: operator.name,
+        label: intl.formatMessage({ id: operator.label })
+      }));
+  }
+  return defaultOperators;
+};
+function changeValueUnit(value, field) {
+  if (microUnits.includes(field)) {
+    if (!Array.isArray(value)) {
+      return microUnitToUnit(value);
+    } else {
+      return value.map((a) => microUnitToUnit(a));
+    }
+  }
+  return value;
+}
+function exportExpertRules(query) {
+  function transformRule(rule) {
+    var _a;
+    const isValueAnArray = Array.isArray(rule.value);
+    const dataType = getDataType(rule.field, rule.operator);
+    return {
+      field: rule.field,
+      operator: dataType !== DataType.PROPERTY ? (_a = Object.values(OPERATOR_OPTIONS).find(
+        (operator) => operator.name === rule.operator
+      )) == null ? void 0 : _a.customName : rule.value.propertyOperator,
+      value: !isValueAnArray && rule.operator !== OperatorType.EXISTS && rule.operator !== OperatorType.NOT_EXISTS && dataType !== DataType.PROPERTY ? changeValueUnit(rule.value, rule.field) : void 0,
+      values: isValueAnArray && dataType !== DataType.PROPERTY ? changeValueUnit(rule.value, rule.field) : void 0,
+      dataType,
+      propertyName: dataType === DataType.PROPERTY ? rule.value.propertyName : void 0,
+      propertyValues: dataType === DataType.PROPERTY ? rule.value.propertyValues : void 0
+    };
+  }
+  function transformGroup(group) {
+    const transformedRules = group.rules.map((ruleOrGroup) => {
+      if ("rules" in ruleOrGroup) {
+        return transformGroup(ruleOrGroup);
+      } else {
+        return transformRule(ruleOrGroup);
+      }
+    });
+    return {
+      combinator: group.combinator,
+      dataType: DataType.COMBINATOR,
+      rules: transformedRules
+    };
+  }
+  return transformGroup(query);
+}
+function importExpertRules(query) {
+  function parseValue(rule) {
+    if (rule.propertyName) {
+      return {
+        propertyName: rule.propertyName,
+        propertyValues: rule.propertyValues,
+        propertyOperator: rule.operator
+      };
+    } else if (rule.values) {
+      if (rule.dataType === DataType.NUMBER) {
+        return rule.values.map((value) => parseFloat(value)).map((numberValue) => {
+          return microUnits.includes(rule.field) ? unitToMicroUnit(numberValue) : numberValue;
+        }).sort((a, b) => a - b);
+      } else {
+        return rule.values.sort();
+      }
+    } else {
+      return microUnits.includes(rule.field) ? unitToMicroUnit(parseFloat(rule.value)) : rule.value;
+    }
+  }
+  function transformRule(rule) {
+    var _a;
+    return {
+      field: rule.field,
+      operator: rule.dataType !== DataType.PROPERTY ? (_a = Object.values(OPERATOR_OPTIONS).find(
+        (operator) => operator.customName === rule.operator
+      )) == null ? void 0 : _a.name : OperatorType.IS,
+      value: parseValue(rule),
+      dataType: rule.operator === OperatorType.IS_PART_OF || rule.operator === OperatorType.IS_NOT_PART_OF ? DataType.STRING : rule.dataType
+    };
+  }
+  function transformGroup(group) {
+    const transformedRules = group.rules.map((ruleOrGroup) => {
+      if ("rules" in ruleOrGroup) {
+        return transformGroup(ruleOrGroup);
+      } else {
+        return transformRule(ruleOrGroup);
+      }
+    });
+    return {
+      combinator: group.combinator,
+      dataType: DataType.COMBINATOR,
+      rules: transformedRules
+    };
+  }
+  return transformGroup(query);
+}
+function countRules(query) {
+  if ("rules" in query) {
+    const group = query;
+    return group.rules.reduce(
+      (sum, ruleOrGroup) => sum + countRules(ruleOrGroup),
+      0
+    );
+  } else {
+    return 1;
+  }
+}
+const testQuery = (check, query) => {
+  const queryValidatorResult = queryValidator(query);
+  return !Object.values(queryValidatorResult).some((ruleValidation) => {
+    if (typeof ruleValidation !== "boolean" && ruleValidation.reasons) {
+      return ruleValidation.reasons.includes(check);
+    }
+    return false;
+  });
+};
+const queryValidator = (query) => {
+  const result = {};
+  const validateRule = (rule) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const isValueAnArray = Array.isArray(rule.value);
+    const isNumberInput = getDataType(rule.field, rule.operator) === DataType.NUMBER && !isValueAnArray;
+    const isStringInput = getDataType(rule.field, rule.operator) === DataType.STRING && !isValueAnArray;
+    if (rule.id && (rule.operator === OPERATOR_OPTIONS.EXISTS.name || rule.operator === OPERATOR_OPTIONS.NOT_EXISTS.name)) {
+      result[rule.id] = {
+        valid: true,
+        reasons: void 0
+      };
+    } else if (rule.id && rule.operator === OPERATOR_OPTIONS.BETWEEN.name) {
+      if (!((_a = rule.value) == null ? void 0 : _a[0]) || !((_b = rule.value) == null ? void 0 : _b[1])) {
+        result[rule.id] = {
+          valid: false,
+          reasons: [RULES.EMPTY_RULE]
+        };
+      } else if (isNaN(parseFloat(rule.value[0])) || isNaN(parseFloat(rule.value[1]))) {
+        result[rule.id] = {
+          valid: false,
+          reasons: [RULES.INCORRECT_RULE]
+        };
+      } else if (parseFloat(rule.value[0]) >= parseFloat(rule.value[1])) {
+        result[rule.id] = {
+          valid: false,
+          reasons: [RULES.BETWEEN_RULE]
+        };
+      }
+    } else if (rule.id && rule.operator === OPERATOR_OPTIONS.IN.name && !((_c = rule.value) == null ? void 0 : _c.length)) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && isStringInput && (rule.value || "").trim() === "") {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && isNumberInput && isNaN(parseFloat(rule.value))) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.INCORRECT_RULE]
+      };
+    } else if (rule.id && (rule.operator === OPERATOR_OPTIONS.IS_PART_OF.name || rule.operator === OPERATOR_OPTIONS.IS_NOT_PART_OF.name) && (!((_d = rule.value) == null ? void 0 : _d.length) || !validate(rule.value[0]))) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    } else if (rule.id && getDataType(rule.field, rule.operator) === DataType.PROPERTY && (isBlankOrEmpty((_e = rule.value) == null ? void 0 : _e.propertyName) || isBlankOrEmpty((_f = rule.value) == null ? void 0 : _f.propertyOperator) || isBlankOrEmpty((_g = rule.value) == null ? void 0 : _g.propertyValues) || !((_i = (_h = rule.value) == null ? void 0 : _h.propertyValues) == null ? void 0 : _i.length))) {
+      result[rule.id] = {
+        valid: false,
+        reasons: [RULES.EMPTY_RULE]
+      };
+    }
+  };
+  const validateGroup = (ruleGroup) => {
+    const reasons = [];
+    if (ruleGroup.rules.length === 0) {
+      reasons.push(RULES.EMPTY_GROUP);
+    }
+    if (ruleGroup.id) {
+      if (reasons.length) {
+        result[ruleGroup.id] = { valid: false, reasons };
+      } else {
+        result[ruleGroup.id] = true;
+      }
+    }
+    ruleGroup.rules.forEach((rule) => {
+      if (typeof rule === "string")
+        ;
+      else if ("rules" in rule) {
+        validateGroup(rule);
+      } else {
+        validateRule(rule);
+      }
+    });
+  };
+  validateGroup(query);
+  return result;
+};
+function recursiveRemove(query, path) {
+  if (getNumberOfSiblings(path, query) === 1 && path.toString() !== [0].toString()) {
+    return recursiveRemove(query, getParentPath(path));
+  } else {
+    return remove(query, path);
+  }
+}
+function getNumberOfSiblings(path, query) {
+  const parentPath = getParentPath(path);
+  const parentGroup = findPath(parentPath, query);
+  return parentGroup.rules.length;
+}
+export {
+  countRules,
+  exportExpertRules,
+  getNumberOfSiblings,
+  getOperators,
+  importExpertRules,
+  queryValidator,
+  recursiveRemove,
+  testQuery
+};

package/dist/components/filter/expert/expert-filter.type.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Copyright (c) 2023, 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 declare enum OperatorType {
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS",
+    LOWER = "LOWER",
+    LOWER_OR_EQUALS = "LOWER_OR_EQUALS",
+    GREATER = "GREATER",
+    GREATER_OR_EQUALS = "GREATER_OR_EQUALS",
+    BETWEEN = "BETWEEN",
+    IN = "IN",
+    IS = "IS",
+    CONTAINS = "CONTAINS",
+    BEGINS_WITH = "BEGINS_WITH",
+    ENDS_WITH = "ENDS_WITH",
+    EXISTS = "EXISTS",
+    NOT_EXISTS = "NOT_EXISTS",
+    IS_PART_OF = "IS_PART_OF",
+    IS_NOT_PART_OF = "IS_NOT_PART_OF"
+}
+export declare enum CombinatorType {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum FieldType {
+    ID = "ID",
+    NAME = "NAME",
+    NOMINAL_VOLTAGE = "NOMINAL_VOLTAGE",
+    MIN_P = "MIN_P",
+    MAX_P = "MAX_P",
+    TARGET_V = "TARGET_V",
+    TARGET_P = "TARGET_P",
+    TARGET_Q = "TARGET_Q",
+    ENERGY_SOURCE = "ENERGY_SOURCE",
+    COUNTRY = "COUNTRY",
+    VOLTAGE_REGULATOR_ON = "VOLTAGE_REGULATOR_ON",
+    PLANNED_ACTIVE_POWER_SET_POINT = "PLANNED_ACTIVE_POWER_SET_POINT",
+    RATED_S = "RATED_S",
+    MARGINAL_COST = "MARGINAL_COST",
+    PLANNED_OUTAGE_RATE = "PLANNED_OUTAGE_RATE",
+    FORCED_OUTAGE_RATE = "FORCED_OUTAGE_RATE",
+    VOLTAGE_LEVEL_ID = "VOLTAGE_LEVEL_ID",
+    P0 = "P0",
+    Q0 = "Q0",
+    LOW_VOLTAGE_LIMIT = "LOW_VOLTAGE_LIMIT",
+    HIGH_VOLTAGE_LIMIT = "HIGH_VOLTAGE_LIMIT",
+    SECTION_COUNT = "SECTION_COUNT",
+    MAXIMUM_SECTION_COUNT = "MAXIMUM_SECTION_COUNT",
+    SHUNT_COMPENSATOR_TYPE = "SHUNT_COMPENSATOR_TYPE",
+    CONNECTED = "CONNECTED",
+    MAX_Q_AT_NOMINAL_V = "MAX_Q_AT_NOMINAL_V",
+    SWITCHED_ON_Q_AT_NOMINAL_V = "SWITCHED_ON_Q_AT_NOMINAL_V",
+    MAX_SUSCEPTANCE = "MAX_SUSCEPTANCE",
+    SWITCHED_ON_SUSCEPTANCE = "SWITCHED_ON_SUSCEPTANCE",
+    CONNECTED_1 = "CONNECTED_1",
+    CONNECTED_2 = "CONNECTED_2",
+    VOLTAGE_LEVEL_ID_1 = "VOLTAGE_LEVEL_ID_1",
+    VOLTAGE_LEVEL_ID_2 = "VOLTAGE_LEVEL_ID_2",
+    NOMINAL_VOLTAGE_1 = "NOMINAL_VOLTAGE_1",
+    NOMINAL_VOLTAGE_2 = "NOMINAL_VOLTAGE_2",
+    COUNTRY_1 = "COUNTRY_1",
+    COUNTRY_2 = "COUNTRY_2",
+    SERIE_RESISTANCE = "SERIE_RESISTANCE",
+    SERIE_REACTANCE = "SERIE_REACTANCE",
+    SHUNT_CONDUCTANCE_1 = "SHUNT_CONDUCTANCE_1",
+    SHUNT_CONDUCTANCE_2 = "SHUNT_CONDUCTANCE_2",
+    SHUNT_SUSCEPTANCE_1 = "SHUNT_SUSCEPTANCE_1",
+    SHUNT_SUSCEPTANCE_2 = "SHUNT_SUSCEPTANCE_2",
+    MAGNETIZING_CONDUCTANCE = "MAGNETIZING_CONDUCTANCE",
+    MAGNETIZING_SUSCEPTANCE = "MAGNETIZING_SUSCEPTANCE",
+    LOAD_TYPE = "LOAD_TYPE",
+    RATED_VOLTAGE_1 = "RATED_VOLTAGE_1",
+    RATED_VOLTAGE_2 = "RATED_VOLTAGE_2",
+    HAS_RATIO_TAP_CHANGER = "HAS_RATIO_TAP_CHANGER",
+    RATIO_REGULATING = "RATIO_REGULATING",
+    LOAD_TAP_CHANGING_CAPABILITIES = "LOAD_TAP_CHANGING_CAPABILITIES",
+    RATIO_REGULATION_MODE = "RATIO_REGULATION_MODE",
+    RATIO_TARGET_V = "RATIO_TARGET_V",
+    HAS_PHASE_TAP_CHANGER = "HAS_PHASE_TAP_CHANGER",
+    PHASE_REGULATING = "PHASE_REGULATING",
+    PHASE_REGULATION_MODE = "PHASE_REGULATION_MODE",
+    PHASE_REGULATION_VALUE = "PHASE_REGULATION_VALUE",
+    PROPERTY = "FREE_PROPERTIES",
+    SUBSTATION_PROPERTY = "SUBSTATION_PROPERTIES",
+    SUBSTATION_PROPERTY_1 = "SUBSTATION_PROPERTIES_1",
+    SUBSTATION_PROPERTY_2 = "SUBSTATION_PROPERTIES_2"
+}
+export declare enum DataType {
+    STRING = "STRING",
+    ENUM = "ENUM",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    COMBINATOR = "COMBINATOR",
+    FILTER_UUID = "FILTER_UUID",
+    PROPERTY = "PROPERTIES"
+}
+export interface RuleTypeExport {
+    field: FieldType;
+    operator: OperatorType;
+    value: string | number | undefined;
+    values: string[] | number[] | undefined;
+    dataType: DataType;
+    propertyName?: string;
+    propertyValues?: string[];
+}
+export interface RuleGroupTypeExport {
+    combinator: CombinatorType;
+    dataType: DataType;
+    rules: (RuleTypeExport | RuleGroupTypeExport)[];
+}

package/dist/components/filter/expert/expert-filter.type.js

@@ -0,0 +1,104 @@
+var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
+  OperatorType2["EQUALS"] = "EQUALS";
+  OperatorType2["NOT_EQUALS"] = "NOT_EQUALS";
+  OperatorType2["LOWER"] = "LOWER";
+  OperatorType2["LOWER_OR_EQUALS"] = "LOWER_OR_EQUALS";
+  OperatorType2["GREATER"] = "GREATER";
+  OperatorType2["GREATER_OR_EQUALS"] = "GREATER_OR_EQUALS";
+  OperatorType2["BETWEEN"] = "BETWEEN";
+  OperatorType2["IN"] = "IN";
+  OperatorType2["IS"] = "IS";
+  OperatorType2["CONTAINS"] = "CONTAINS";
+  OperatorType2["BEGINS_WITH"] = "BEGINS_WITH";
+  OperatorType2["ENDS_WITH"] = "ENDS_WITH";
+  OperatorType2["EXISTS"] = "EXISTS";
+  OperatorType2["NOT_EXISTS"] = "NOT_EXISTS";
+  OperatorType2["IS_PART_OF"] = "IS_PART_OF";
+  OperatorType2["IS_NOT_PART_OF"] = "IS_NOT_PART_OF";
+  return OperatorType2;
+})(OperatorType || {});
+var CombinatorType = /* @__PURE__ */ ((CombinatorType2) => {
+  CombinatorType2["AND"] = "AND";
+  CombinatorType2["OR"] = "OR";
+  return CombinatorType2;
+})(CombinatorType || {});
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2["ID"] = "ID";
+  FieldType2["NAME"] = "NAME";
+  FieldType2["NOMINAL_VOLTAGE"] = "NOMINAL_VOLTAGE";
+  FieldType2["MIN_P"] = "MIN_P";
+  FieldType2["MAX_P"] = "MAX_P";
+  FieldType2["TARGET_V"] = "TARGET_V";
+  FieldType2["TARGET_P"] = "TARGET_P";
+  FieldType2["TARGET_Q"] = "TARGET_Q";
+  FieldType2["ENERGY_SOURCE"] = "ENERGY_SOURCE";
+  FieldType2["COUNTRY"] = "COUNTRY";
+  FieldType2["VOLTAGE_REGULATOR_ON"] = "VOLTAGE_REGULATOR_ON";
+  FieldType2["PLANNED_ACTIVE_POWER_SET_POINT"] = "PLANNED_ACTIVE_POWER_SET_POINT";
+  FieldType2["RATED_S"] = "RATED_S";
+  FieldType2["MARGINAL_COST"] = "MARGINAL_COST";
+  FieldType2["PLANNED_OUTAGE_RATE"] = "PLANNED_OUTAGE_RATE";
+  FieldType2["FORCED_OUTAGE_RATE"] = "FORCED_OUTAGE_RATE";
+  FieldType2["VOLTAGE_LEVEL_ID"] = "VOLTAGE_LEVEL_ID";
+  FieldType2["P0"] = "P0";
+  FieldType2["Q0"] = "Q0";
+  FieldType2["LOW_VOLTAGE_LIMIT"] = "LOW_VOLTAGE_LIMIT";
+  FieldType2["HIGH_VOLTAGE_LIMIT"] = "HIGH_VOLTAGE_LIMIT";
+  FieldType2["SECTION_COUNT"] = "SECTION_COUNT";
+  FieldType2["MAXIMUM_SECTION_COUNT"] = "MAXIMUM_SECTION_COUNT";
+  FieldType2["SHUNT_COMPENSATOR_TYPE"] = "SHUNT_COMPENSATOR_TYPE";
+  FieldType2["CONNECTED"] = "CONNECTED";
+  FieldType2["MAX_Q_AT_NOMINAL_V"] = "MAX_Q_AT_NOMINAL_V";
+  FieldType2["SWITCHED_ON_Q_AT_NOMINAL_V"] = "SWITCHED_ON_Q_AT_NOMINAL_V";
+  FieldType2["MAX_SUSCEPTANCE"] = "MAX_SUSCEPTANCE";
+  FieldType2["SWITCHED_ON_SUSCEPTANCE"] = "SWITCHED_ON_SUSCEPTANCE";
+  FieldType2["CONNECTED_1"] = "CONNECTED_1";
+  FieldType2["CONNECTED_2"] = "CONNECTED_2";
+  FieldType2["VOLTAGE_LEVEL_ID_1"] = "VOLTAGE_LEVEL_ID_1";
+  FieldType2["VOLTAGE_LEVEL_ID_2"] = "VOLTAGE_LEVEL_ID_2";
+  FieldType2["NOMINAL_VOLTAGE_1"] = "NOMINAL_VOLTAGE_1";
+  FieldType2["NOMINAL_VOLTAGE_2"] = "NOMINAL_VOLTAGE_2";
+  FieldType2["COUNTRY_1"] = "COUNTRY_1";
+  FieldType2["COUNTRY_2"] = "COUNTRY_2";
+  FieldType2["SERIE_RESISTANCE"] = "SERIE_RESISTANCE";
+  FieldType2["SERIE_REACTANCE"] = "SERIE_REACTANCE";
+  FieldType2["SHUNT_CONDUCTANCE_1"] = "SHUNT_CONDUCTANCE_1";
+  FieldType2["SHUNT_CONDUCTANCE_2"] = "SHUNT_CONDUCTANCE_2";
+  FieldType2["SHUNT_SUSCEPTANCE_1"] = "SHUNT_SUSCEPTANCE_1";
+  FieldType2["SHUNT_SUSCEPTANCE_2"] = "SHUNT_SUSCEPTANCE_2";
+  FieldType2["MAGNETIZING_CONDUCTANCE"] = "MAGNETIZING_CONDUCTANCE";
+  FieldType2["MAGNETIZING_SUSCEPTANCE"] = "MAGNETIZING_SUSCEPTANCE";
+  FieldType2["LOAD_TYPE"] = "LOAD_TYPE";
+  FieldType2["RATED_VOLTAGE_1"] = "RATED_VOLTAGE_1";
+  FieldType2["RATED_VOLTAGE_2"] = "RATED_VOLTAGE_2";
+  FieldType2["HAS_RATIO_TAP_CHANGER"] = "HAS_RATIO_TAP_CHANGER";
+  FieldType2["RATIO_REGULATING"] = "RATIO_REGULATING";
+  FieldType2["LOAD_TAP_CHANGING_CAPABILITIES"] = "LOAD_TAP_CHANGING_CAPABILITIES";
+  FieldType2["RATIO_REGULATION_MODE"] = "RATIO_REGULATION_MODE";
+  FieldType2["RATIO_TARGET_V"] = "RATIO_TARGET_V";
+  FieldType2["HAS_PHASE_TAP_CHANGER"] = "HAS_PHASE_TAP_CHANGER";
+  FieldType2["PHASE_REGULATING"] = "PHASE_REGULATING";
+  FieldType2["PHASE_REGULATION_MODE"] = "PHASE_REGULATION_MODE";
+  FieldType2["PHASE_REGULATION_VALUE"] = "PHASE_REGULATION_VALUE";
+  FieldType2["PROPERTY"] = "FREE_PROPERTIES";
+  FieldType2["SUBSTATION_PROPERTY"] = "SUBSTATION_PROPERTIES";
+  FieldType2["SUBSTATION_PROPERTY_1"] = "SUBSTATION_PROPERTIES_1";
+  FieldType2["SUBSTATION_PROPERTY_2"] = "SUBSTATION_PROPERTIES_2";
+  return FieldType2;
+})(FieldType || {});
+var DataType = /* @__PURE__ */ ((DataType2) => {
+  DataType2["STRING"] = "STRING";
+  DataType2["ENUM"] = "ENUM";
+  DataType2["NUMBER"] = "NUMBER";
+  DataType2["BOOLEAN"] = "BOOLEAN";
+  DataType2["COMBINATOR"] = "COMBINATOR";
+  DataType2["FILTER_UUID"] = "FILTER_UUID";
+  DataType2["PROPERTY"] = "PROPERTIES";
+  return DataType2;
+})(DataType || {});
+export {
+  CombinatorType,
+  DataType,
+  FieldType,
+  OperatorType
+};

package/dist/components/filter/explicit-naming/explicit-naming-filter-edition-dialog.d.ts

@@ -0,0 +1,22 @@
+import { elementExistsType } from '../criteria-based/criteria-based-filter-edition-dialog';
+import { UUID } from 'crypto';
+import { FunctionComponent } from 'react';
+
+interface ExplicitNamingFilterEditionDialogProps {
+    id: string;
+    name: string;
+    titleId: string;
+    open: boolean;
+    onClose: () => void;
+    broadcastChannel: BroadcastChannel;
+    selectionForCopy: any;
+    setSelectionForCopy: (selection: any) => void;
+    getFilterById: (id: string) => Promise<any>;
+    createFilter: (filter: any, name: string, description: string, activeDirectory: any) => Promise<void>;
+    saveFilter: (filter: any, name: string) => Promise<void>;
+    activeDirectory?: UUID;
+    elementExists?: elementExistsType;
+    language?: string;
+}
+declare const ExplicitNamingFilterEditionDialog: FunctionComponent<ExplicitNamingFilterEditionDialogProps>;
+export default ExplicitNamingFilterEditionDialog;

package/dist/components/filter/explicit-naming/explicit-naming-filter-edition-dialog.js

@@ -0,0 +1,19 @@
+import "react/jsx-runtime";
+import "react";
+import "prop-types";
+import "../utils/filters-utils.js";
+import "react-hook-form";
+import "@hookform/resolvers/yup";
+import "../../../hooks/useSnackMessage.js";
+import "../../dialogs/custom-mui-dialog.js";
+import "../../../utils/yup-config.js";
+import { a } from "../../../chunks/criteria-based-filter-edition-dialog.BEXoNmzz.js";
+import "../constants/field-constants.js";
+import "uuid";
+import "../constants/equipment-types.js";
+import "../constants/filter-constants.js";
+import "../../../utils/FetchStatus.js";
+import "yup";
+export {
+  a as default
+};

package/dist/components/filter/explicit-naming/explicit-naming-filter-form.d.ts

@@ -0,0 +1,22 @@
+import { DISTRIBUTION_KEY } from '../constants/filter-constants';
+import { default as yup } from '../../../utils/yup-config';
+import { FieldConstants } from '../constants/field-constants';
+import { FunctionComponent } from 'react';
+
+export declare const FILTER_EQUIPMENTS_ATTRIBUTES = "filterEquipmentsAttributes";
+export declare const explicitNamingFilterSchema: {
+    filterEquipmentsAttributes: yup.ArraySchema<{
+        equipmentID?: string | null | undefined;
+        distributionKey?: number | null | undefined;
+    }[] | undefined, yup.AnyObject, "", "">;
+};
+interface FilterTableRow {
+    [FieldConstants.AG_GRID_ROW_UUID]: string;
+    [FieldConstants.EQUIPMENT_ID]: string;
+    [DISTRIBUTION_KEY]: number | null;
+}
+export declare function getExplicitNamingFilterEmptyFormData(): {
+    filterEquipmentsAttributes: FilterTableRow[];
+};
+declare const ExplicitNamingFilterForm: FunctionComponent;
+export default ExplicitNamingFilterForm;