@m4l/components 1.0.9 → 1.0.11

package/components/AccountPopover/{index.85964263.js → index.62b1290b.js}

@@ -6,8 +6,8 @@ import { unstable_composeClasses } from "@mui/base";
 import { T as TEST_PROP_ID } from "../areas/constants.0d3ba950.js";
 import { A as Avatar } from "../mui_extended/Avatar/index.12b96914.js";
 import { C as CircularProgress } from "../mui_extended/CircularProgress/index.967e70b7.js";
-import { P as Popover } from "../mui_extended/Popover/index.fda32ba1.js";
-import { I as Icon } from "../Icon/index.0d591435.js";
+import { P as Popover } from "../mui_extended/Popover/index.146ded9e.js";
+import { I as Icon } from "../Icon/index.8ecfb193.js";
 import clsx from "clsx";
 const componentName = "M4LAccountPopover";
 generateUtilityClasses(

package/components/AppBar/{index.233917e6.js → index.b48343d8.js}

@@ -5,9 +5,9 @@ import { useEnvironment, useModuleDictionary } from "@m4l/core";
 import { T as TEST_PROP_ID } from "../areas/constants.0d3ba950.js";
 import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
 import { unstable_composeClasses } from "@mui/base";
-import { I as Image } from "../Image/index.7b1ce7d6.js";
+import { I as Image } from "../Image/index.4a822ede.js";
 import { T as Typography } from "../mui_extended/Typography/index.463f613f.js";
-import { I as IconButton } from "../mui_extended/IconButton/index.20a5a0be.js";
+import { I as IconButton } from "../mui_extended/IconButton/index.d5b273e6.js";
 const AppBarRoot = styled("header")(({ theme }) => ({
   ...theme.components?.M4LAppBar?.styleOverrides
 }));

package/components/CommonActions/{index.5f5362d4.js → index.19f39dca.js}

@@ -4,11 +4,11 @@ import clsx from "clsx";
 import { T as TEST_PROP_ID } from "../areas/constants.0d3ba950.js";
 import { styled } from "@mui/material/styles";
 import { useModuleDictionary, useModuleSkeleton } from "@m4l/core";
-import { B as Button, L as LoadingButton } from "../mui_extended/Button/index.6276c580.js";
+import { B as Button, L as LoadingButton } from "../mui_extended/Button/index.52852c42.js";
 import { useFormContext, useFormState } from "react-hook-form";
-import { u as useModal } from "../../hooks/useModal/index.20c3f2be.js";
+import { u as useModal } from "../../hooks/useModal/index.d14c7e46.js";
 import { u as useWindowToolsMF } from "../areas/hooks/useWindowToolsMF/index.09801b66.js";
-import { W as WindowConfirm } from "../modal/WindowConfirm.21342f0a.js";
+import { W as WindowConfirm } from "../modal/WindowConfirm.243e1bef.js";
 import { generateUtilityClasses, Skeleton } from "@mui/material";
 import { unstable_composeClasses } from "@mui/base";
 import { g as getComponentUtilityClass } from "../../utils/index.c64c2dd1.js";

package/components/DynamicFilter/helpers/index.609b3915.js

@@ -0,0 +1,557 @@
+import * as Yup from "yup";
+import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../areas/dictionary.6168209a.js";
+import { B as BOOLEAN_OPERATORS, S as STRING_OPERATORS, b as DATE_TIME_OPERATORS, N as NUMBER_OPERATORS, c as SELECT_OPERATORS } from "../../areas/constants.0d3ba950.js";
+import { B as BooleanFilter, S as StringFilter, D as DateTimeFilter, N as NumberFilter, a as SelectFilter, f as fieldFactory } from "../subcomponents/index.86c6fda2.js";
+import { i as isValidDate } from "../../../utils/index.c64c2dd1.js";
+class BooleanFilterHelpers {
+  getComponent() {
+    return BooleanFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultOperand1 = field.defaultOperand1;
+    const defaultFilter = {
+      id: 0,
+      fieldType: "boolean",
+      field,
+      fixed,
+      isSet: true,
+      operator: "e",
+      operand1: true
+    };
+    if (defaultOperand1 !== void 0 && typeof defaultOperand1 === "boolean") {
+      defaultFilter.operand1 = defaultOperand1;
+    }
+    return defaultFilter;
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1?.value || false;
+    return {
+      fieldType: "boolean",
+      operator,
+      operand1
+    };
+  }
+  getFormValue(field, getLabel, filterValue) {
+    const filterValueBoolean = filterValue ? filterValue : void 0;
+    const operator = filterValueBoolean ? filterValueBoolean.operator : field.defaultOperator ?? "e";
+    const formValueOperand1 = filterValueBoolean ? {
+      value: filterValueBoolean.operand1,
+      label: getLabel(getDynamicFilterDictionary(`operand_${filterValueBoolean.operand1}`))
+    } : null;
+    return {
+      fieldType: "boolean",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1
+    };
+  }
+  getLabels(filter, getLabel, _formatters, _field) {
+    const labelOperands = filter.operand1 ? getLabel(getDynamicFilterDictionary("operand_true")) : getLabel(getDynamicFilterDictionary("operand_false"));
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(`dynamic_filter.error_operator_required`)),
+      formValueOperand1: Yup.object().nullable().required(getLabel(`dynamic_filter.error_operand_required`))
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (BOOLEAN_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    return typeof filter.operand1 === "boolean";
+  }
+}
+class StringFilterHelpers {
+  getComponent() {
+    return StringFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultOperand1 = field.defaultOperand1;
+    const defaultFilter = {
+      id: 0,
+      fieldType: "string",
+      field,
+      fixed,
+      isSet: false,
+      operator: "c",
+      operand1: ""
+    };
+    if (defaultOperand1 !== void 0 && typeof defaultOperand1 === "string") {
+      defaultFilter.operand1 = defaultOperand1;
+    }
+    return defaultFilter;
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1;
+    return {
+      fieldType: "string",
+      operator,
+      operand1
+    };
+  }
+  getFormValue(field, getLabel, filterValue) {
+    const filterValueString = filterValue;
+    const operator = filterValueString ? filterValueString.operator : field.defaultOperator ?? "c";
+    const formValueOperand1 = filterValueString ? filterValueString.operand1 : "";
+    return {
+      fieldType: "string",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1
+    };
+  }
+  getLabels(filter, getLabel, _formatters, _field) {
+    const labelOperands = filter.operand1 !== void 0 ? filter.operand1 + "" : "";
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(getDynamicFilterDictionary(DICCTIONARY.operator_required))),
+      formValueOperand1: Yup.string().required(
+        getLabel(getDynamicFilterDictionary(DICCTIONARY.error_operand_required))
+      )
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (STRING_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (typeof filter.operand1 !== "string") {
+      return false;
+    }
+    return true;
+  }
+}
+class DateTimeFilterHelpers {
+  getComponent() {
+    return DateTimeFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultStartDate = new Date();
+    const defaultEndDate = new Date();
+    defaultStartDate.setHours(0, 0, 0, 0);
+    defaultEndDate.setHours(23, 59, 59, 999);
+    const defaultOperand1 = field.defaultOperand1 && field.defaultOperand1 instanceof Date ? field.defaultOperand1 : defaultStartDate;
+    const defaultOperand2 = field.defaultOperand2 && field.defaultOperand2 instanceof Date ? field.defaultOperand2 : defaultEndDate;
+    return {
+      id: 0,
+      fieldType: "datetime",
+      field,
+      fixed,
+      isSet: true,
+      operator: "b",
+      operand1: defaultOperand1,
+      operand2: defaultOperand2
+    };
+  }
+  getFormValue(field, getLabel, filterValueDateTime) {
+    const filterValue = filterValueDateTime;
+    const operator = filterValue ? filterValue.operator : field.defaultOperator ?? "b";
+    const defaultStartDate = new Date();
+    const defaultEndDate = new Date();
+    const defaultOperand1 = field.defaultOperand1 && field.defaultOperand1 instanceof Date ? field.defaultOperand1 : defaultStartDate;
+    const defaultOperand2 = field.defaultOperand2 && field.defaultOperand2 instanceof Date ? field.defaultOperand2 : defaultEndDate;
+    const formValueOperand1 = filterValue ? filterValue.operand1 : defaultOperand1;
+    const formValueOperand2 = filterValue && filterValue.operator === "b" ? filterValue.operand2 : defaultOperand2;
+    return {
+      fieldType: "datetime",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1,
+      formValueOperand2
+    };
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1;
+    if (operator === "b") {
+      const operand2 = formFilterValue.formValueOperand2;
+      return {
+        fieldType: "datetime",
+        operator,
+        operand1,
+        operand2
+      };
+    } else {
+      return {
+        fieldType: "datetime",
+        operator,
+        operand1
+      };
+    }
+  }
+  getLabels(filter, getLabel, formatters, _field) {
+    const { dateFormatter } = formatters;
+    let labelOperands;
+    if (filter.operator === "b") {
+      labelOperands = filter.operand1 && filter.operand2 ? `${dateFormatter.formatDate(
+        filter.operand1,
+        dateFormatter.datetimeFormat
+      )} - ${dateFormatter.formatDate(filter.operand2, dateFormatter.datetimeFormat)}` : "";
+    } else {
+      labelOperands = filter.operand1 ? dateFormatter.formatDate(filter.operand1, dateFormatter.datetimeFormat) : "";
+    }
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(getDynamicFilterDictionary(DICCTIONARY.operator_required))),
+      formValueOperand1: Yup.date().required(getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))).typeError(getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))),
+      formValueOperand2: Yup.mixed().when(["formValueOperator.id"], {
+        is: "b",
+        then: Yup.date().typeError(getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))).min(
+          Yup.ref("formValueOperand1"),
+          getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))
+        )
+      })
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (DATE_TIME_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (typeof filter.operand1 !== "string") {
+      return false;
+    }
+    if (!isValidDate(new Date(filter.operand1))) {
+      return false;
+    }
+    if (filter.operator === "b") {
+      if (typeof filter.operand2 !== "string") {
+        return false;
+      }
+      if (!isValidDate(new Date(filter.operand1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+class NumberFilterHelpers {
+  getComponent() {
+    return NumberFilter;
+  }
+  getDefaultFilter(fieldNumber, fixed) {
+    const field = fieldNumber;
+    const dOperator = field.defaultOperator ?? "e";
+    const defaultOperand1 = field.defaultOperand1 ?? null;
+    const defaultOperand2 = field.defaultOperand2 ?? null;
+    return {
+      id: 0,
+      fieldType: "number",
+      field,
+      fixed,
+      isSet: false,
+      operator: dOperator,
+      operand1: defaultOperand1,
+      operand2: defaultOperand2
+    };
+  }
+  getFormValue(field, getLabel, filterValue) {
+    const filterValueNumber = filterValue;
+    const operator = filterValueNumber ? filterValueNumber.operator : field.defaultOperator ?? "e";
+    const formValueOperand1 = filterValueNumber ? filterValueNumber.operand1 : null;
+    const formValueOperand2 = filterValueNumber && filterValueNumber?.operator === "b" ? filterValueNumber.operand2 : null;
+    return {
+      fieldType: "number",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1,
+      formValueOperand2
+    };
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1 ? formFilterValue.formValueOperand1 : 0;
+    if (operator === "b") {
+      const operand2 = formFilterValue.formValueOperand2 ? formFilterValue.formValueOperand2 : 0;
+      return {
+        fieldType: "number",
+        operator,
+        operand1,
+        operand2
+      };
+    } else {
+      return {
+        fieldType: "number",
+        operator,
+        operand1
+      };
+    }
+  }
+  getLabels(filter, getLabel, _formatters, _field) {
+    let labelOperands;
+    if (filter.operator === "b") {
+      labelOperands = filter.operand1 && filter.operand2 ? `${filter.operand1} - ${filter.operand2}` : "";
+    } else {
+      labelOperands = filter.operand1 !== void 0 ? filter.operand1 + "" : "";
+    }
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(`dynamic_filter.error_operator_required`)),
+      formValueOperand1: Yup.number().typeError(
+        getLabel(`dynamic_filter.error_operand_mustbe_number`)
+      ),
+      formValueOperand2: Yup.mixed().when(["formValueOperator.id"], {
+        is: "b",
+        then: Yup.number().typeError(getLabel(`dynamic_filter.error_operand_mustbe_number`)).min(Yup.ref("formValueOperand1"), getLabel(`dynamic_filter.error_less_than_start`))
+      })
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "number") {
+      return false;
+    }
+    if (NUMBER_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (typeof filter.operand1 !== "number") {
+      return false;
+    }
+    if (filter.operator === "b" && typeof filter.operand2 !== "number") {
+      return false;
+    }
+    return true;
+  }
+}
+function filterValidOperandsArraySelect(operandsArray, field) {
+  const operandsArrayFormatted = Array.isArray(operandsArray) ? operandsArray : [operandsArray];
+  const getOptionId = field?.selectOptions?.getOptionId;
+  const getOptionLabel = field?.selectOptions?.getOptionLabel;
+  return operandsArrayFormatted?.filter((operand) => {
+    return typeof operand === "object" && getOptionId?.(operand) && getOptionLabel?.(operand);
+  });
+}
+class SelectFilterHelpers {
+  getComponent() {
+    return SelectFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultOperand = field.defaultOperandsArray;
+    const defaultFilter = {
+      id: 0,
+      fieldType: "select",
+      field,
+      fixed,
+      isSet: true,
+      operator: "in",
+      operandsArray: []
+    };
+    if (defaultOperand !== void 0 && Array.isArray(defaultOperand)) {
+      const validOperandsArray = filterValidOperandsArraySelect(defaultOperand, field);
+      defaultFilter.operandsArray = validOperandsArray || [];
+    }
+    return defaultFilter;
+  }
+  getFormValue(field, getLabel, filterValueSelect) {
+    const filterValue = filterValueSelect ? filterValueSelect : void 0;
+    const isMultiple = field?.selectOptions?.multiple ?? false;
+    const formValueOperandsArray = isMultiple ? filterValueSelect?.operandsArray : filterValueSelect?.operandsArray?.[0] || filterValueSelect?.operandsArray;
+    const operator = filterValue ? filterValue.operator : field.defaultOperator ?? "in";
+    return {
+      fieldType: "select",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperandsArray
+    };
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operandsArray = Array.isArray(formFilterValue.formValueOperandsArray) ? formFilterValue.formValueOperandsArray : [formFilterValue.formValueOperandsArray];
+    return {
+      fieldType: "select",
+      operator,
+      operandsArray
+    };
+  }
+  getLabels(filter, getLabel, _formatters, field) {
+    const operandsArray = filter.operandsArray;
+    const labelOperands = operandsArray?.reduce?.((label, operand) => {
+      const textLabel = field.selectOptions?.getOptionLabel?.(operand) || "";
+      return label ? `${label} | ${textLabel}` : textLabel;
+    }, "")?.toString() || "";
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(`dynamic_filter.error_operator_required`)),
+      formValueOperandsArray: Yup.lazy((value) => {
+        return Array.isArray(value) ? Yup.array().min(1, getLabel(`dynamic_filter.error_operand_required`)).of(Yup.object().nullable()).required(getLabel(`dynamic_filter.error_operand_required`)) : Yup.object().nullable().required(getLabel(`dynamic_filter.error_operand_required`));
+      })
+    });
+  }
+  verifyFilter(filter, field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (!field) {
+      return false;
+    }
+    if (SELECT_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (!filter.operandsArray || typeof filter.operandsArray !== "object") {
+      return false;
+    }
+    const validOperandsArray = filterValidOperandsArraySelect(
+      filter.operandsArray,
+      field
+    );
+    if (!validOperandsArray || validOperandsArray?.length === 0) {
+      return false;
+    }
+    return true;
+  }
+}
+function getPurgedInitialFiltersApplied(fields, initialFilters, getFieldByName) {
+  const newFilters = [];
+  const fixedFields = [];
+  for (let index = 0; index < initialFilters.length; index++) {
+    try {
+      const initialFilter = initialFilters[index];
+      const field = getFieldByName(initialFilter.name);
+      const filter = {
+        id: 0,
+        isSet: true,
+        fixed: false,
+        field,
+        fieldType: field.type,
+        operator: initialFilters[index].operator,
+        operand1: initialFilters[index].operand1,
+        operand2: initialFilters[index].operand2,
+        operandsArray: initialFilters[index].operandsArray
+      };
+      if (!field)
+        continue;
+      const canAddField = fieldFactory(field.type).verifyFilter(initialFilter, field);
+      if (canAddField) {
+        if (filter.fieldType === "datetime") {
+          filter.operand1 = new Date(filter.operand1 + "");
+          filter.operand2 = new Date(filter.operand2 + "");
+        }
+        if (field.presence === "fixed") {
+          if (fixedFields.findIndex((f) => f === field.name) === -1) {
+            filter.fixed = true;
+            fixedFields.push(field.name);
+          } else {
+            filter.fixed = false;
+          }
+        }
+        filter.isSet = true;
+        filter.id = newFilters.length + 1;
+        newFilters.push(filter);
+      }
+    } catch (error) {
+    }
+  }
+  for (let index = 0; index < fields.length; index++) {
+    const field = fields[index];
+    if (field.presence === "initialized" || field.presence === "fixed") {
+      if (!initialFilters.find((f) => f.name === field.name)) {
+        const newFilter = fieldFactory(field.type).getDefaultFilter(
+          field,
+          field.presence === "fixed"
+        );
+        newFilter.id = newFilters.length + 1;
+        newFilters.push(newFilter);
+      }
+    }
+  }
+  return newFilters;
+}
+const formatToRawFilter = (appliedFilters) => {
+  return appliedFilters.map((af) => {
+    let oa = void 0;
+    if (af.field.type === "select" && af.operandsArray) {
+      oa = Array.isArray(af.operandsArray) ? af.operandsArray.map(af.field.selectOptions.getOptionId) : [af.field.selectOptions.getOptionId(af.operandsArray)];
+    }
+    return {
+      n: af.field.name,
+      o: af.operator,
+      o1: af.operand1,
+      o2: af.operator === "b" ? af.operand2 : void 0,
+      oa
+    };
+  });
+};
+function formatToInitialFilters(appliedFilters) {
+  return appliedFilters.map((appliedFilter) => {
+    const ret = {
+      name: appliedFilter.field.name,
+      operator: appliedFilter.operator,
+      operand1: appliedFilter.operand1,
+      operand2: appliedFilter.operator === "b" ? appliedFilter.operand2 : void 0
+    };
+    if (appliedFilter.fieldType === "datetime") {
+      ret.operand1 = appliedFilter.operand1.toISOString();
+      ret.operand2 = appliedFilter.operator === "b" ? appliedFilter.operand2.toISOString() : void 0;
+    }
+    if (appliedFilter.fieldType === "select") {
+      const validOperandsArray = filterValidOperandsArraySelect(
+        appliedFilter.operandsArray,
+        appliedFilter.field
+      );
+      if (validOperandsArray && validOperandsArray?.length > 0) {
+        ret.operandsArray = validOperandsArray;
+      }
+    }
+    if (ret.operand2 === void 0) {
+      delete ret.operand2;
+    }
+    return ret;
+  });
+}
+export {
+  BooleanFilterHelpers as B,
+  DateTimeFilterHelpers as D,
+  NumberFilterHelpers as N,
+  StringFilterHelpers as S,
+  formatToRawFilter as a,
+  SelectFilterHelpers as b,
+  formatToInitialFilters as f,
+  getPurgedInitialFiltersApplied as g
+};