@m4l/testing 0.0.22 → 0.0.23-AQ200320226-2.beta

package/e2e/commands/components/Form/cypress/assertInitialFormState/type.d.ts

@@ -0,0 +1,105 @@
+interface BaseInput {
+    /**
+     * Index of the field in the form
+     */
+    index?: number;
+    /**
+     * Value of the field visible by default
+     */
+    valueVisibleByDefault?: string;
+}
+interface InputWithoutOptions extends BaseInput {
+    /**
+     * Type of the element in the form (input, textarea)
+     */
+    typeElement: 'input' | 'textarea';
+    /**
+     * Type of the value of the input (string, number)
+     */
+    typeValue?: 'string' | 'number';
+    /**
+     * Value to write in the input
+     */
+    valueToWrite?: string;
+}
+interface InputWithOptions extends BaseInput {
+    typeElement: 'select';
+    /**
+     * Alias of the endpoint to wait for. (Cypress alias syntax with intercept)
+     * Example: '@localesList'
+     */
+    endpointToWait: string;
+    /**
+     * Options of the autocomplete. Only used for autocompleteAsync or select type.
+     */
+    options: string[];
+    /**
+     * Index to select in the list of options
+     * by default is index 0 (first option)
+     */
+    optionIndexToSelect?: number;
+}
+export type InputsForm = InputWithoutOptions | InputWithOptions;
+interface AssertInitialFormStateBaseParams {
+    /**
+     * Endpoint to wait for. (Cypress alias syntax with intercept)
+     * Example: '@getForm'
+     */
+    endpointToWait?: string;
+}
+export type InitialField = Omit<InputsForm, 'valueToWrite' | 'optionIndexToSelect' | 'options' | 'valueVisibleByDefault'> & {
+    /**
+     * Expected value of the field when form is initially loaded. By default is empty string.
+     * Example: 'demo_operative'
+     */
+    expectedValue?: string;
+    /**
+     * Whether the field should be enabled on initial load.
+     * By default the assertion expects enabled.
+     */
+    enabled?: boolean;
+};
+/**
+ * Step to validate.
+ * Example:
+ * {
+ *   stepperIndex: 1,
+ *   inputs: [{ typeElement: 'input', valueVisibleByDefault: '' }]
+ * }
+ */
+export interface Step {
+    /**
+     * Stepper index to validate.
+     * Example: 1
+     */
+    stepperIndex: number;
+    /**
+     * Inputs to validate in the selected step.
+     */
+    inputs: InitialField[];
+}
+export interface AssertInitialFormStateWithStepper extends AssertInitialFormStateBaseParams {
+    /**
+     * Steps to validate.
+     * Example:
+     * [{ stepperIndex: 1, inputs: [{ typeElement: 'input', valueVisibleByDefault: '' }] }]
+     */
+    steps: Step[];
+    /**
+     * Label of the next button.
+     * By default: 'N_D:[stepper.label_next_button]'
+     */
+    labelNextButton?: string;
+    inputs?: never;
+}
+export interface AssertInitialFormStateWithoutStepper extends AssertInitialFormStateBaseParams {
+    /**
+     * Inputs to validate when the form has no stepper.
+     * Example:
+     * [{ typeElement: 'input', index: 0, expectedValue: '' }]
+     */
+    inputs: InitialField[];
+    steps?: never;
+}
+export type AssertInitialFormState = AssertInitialFormStateWithStepper | AssertInitialFormStateWithoutStepper;
+export {};

package/e2e/commands/components/Form/cypress/assertInitialFormState/type.js

@@ -0,0 +1 @@
+

package/e2e/commands/components/Form/cypress/assertMandatoryFields/assertMandatoryFields.d.ts

@@ -0,0 +1,17 @@
+import { AssertMandatoryFields } from './type';
+/**
+ * function to assert mandatory fields
+ * @param props - The properties to assert mandatory fields
+ * @example
+ * {
+ *   formFieldItems: [
+ *     {
+ *       name: 'name',
+ *       evaluateField: true,
+ *       mandatory: true,
+ *     },
+ *   ],
+ *   propertyValueSelector: '[data-testid="m4l-property-value-root-name"]',
+ * }
+ */
+export declare const assertMandatoryFields: ({ formFieldItems, propertyValueSelector }: AssertMandatoryFields) => void;

package/e2e/commands/components/Form/cypress/assertMandatoryFields/assertMandatoryFields.js

@@ -0,0 +1,14 @@
+import { g as r } from "../getFormScope/getFormScope.js";
+const a = (s, e) => r().find(`${e}[data-testid*="${s}"]`), l = ({ formFieldItems: s, propertyValueSelector: e }) => {
+  s.forEach((t) => {
+    if (t.evaluateField !== !1)
+      if (a(t.name, e).should("contain.text", t.label), t.mandatory === !0) {
+        const o = a(t.name, e).find('[class*="M4LHelperError-root"]');
+        o.should("exist"), o.should("be.visible");
+      } else
+        a(t.name, e).find('[class*="M4LHelperError-root"]').should("not.exist");
+  });
+};
+export {
+  l as a
+};

package/e2e/commands/components/Form/cypress/assertMandatoryFields/type.d.ts

@@ -0,0 +1,28 @@
+export type FormConfig = {
+    name: string;
+    label: string;
+    evaluateField: boolean;
+    mandatory?: boolean;
+};
+export interface AssertMandatoryFields {
+    /**
+     * Form field items to assert if are mandatory
+     * @example
+     * [
+     *   {
+     *     name: 'name',
+     *     value: 'John Doe',
+     *     evaluateValue: true,
+     *     text: 'Name',
+     *     mandatory: true,
+     *   },
+     * ]
+     */
+    formFieldItems: FormConfig[];
+    /**
+     * Property value selector to assert mandatory fields. This property containts the selector of the property value of the form field.
+     * @example
+     * '[data-testid="m4l-property-value-root-name"]'
+     */
+    propertyValueSelector: string;
+}

package/e2e/commands/components/Form/cypress/assertMandatoryFields/type.js

@@ -0,0 +1 @@
+

package/e2e/commands/components/Form/cypress/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const WINDOW_BASE_SELECTOR = "[class*=\"M4LWindowBase-contentWindowBase\"]";
+export declare const PAPER_FORM_SELECTOR = "[class*=\"M4LPaperForm-containerContent\"]";
+export declare const DEFAULT_NEXT_LABEL = "N_D:[stepper.label_next_button]";

package/e2e/commands/components/Form/cypress/constants.js

@@ -0,0 +1,6 @@
+const n = '[class*="M4LWindowBase-contentWindowBase"]', s = '[class*="M4LPaperForm-containerContent"]', t = "N_D:[stepper.label_next_button]";
+export {
+  t as D,
+  s as P,
+  n as W
+};

package/e2e/commands/components/Form/cypress/fillAndAssertFormFields/fillAndAssertFormFields.d.ts

@@ -0,0 +1,8 @@
+import { FillAndAssertFormFields } from './type';
+/**
+ * Fill and validate the inputs of the form with the data of the form
+ * @param inputs - The inputs to validate
+ * @param stepIndex - The step index to get the scope of the form
+ * @returns void
+ */
+export declare const fillAndAssertFormFields: ({ inputs, stepIndex }: FillAndAssertFormFields) => void;

package/e2e/commands/components/Form/cypress/fillAndAssertFormFields/fillAndAssertFormFields.js

@@ -0,0 +1,29 @@
+import { g as r } from "../../helpers/getFieldNameDomElement.js";
+import { g as i } from "../getFormScope/getFormScope.js";
+const c = (l) => l.get('[class*="MuiAutocomplete-listbox"]').find('[class*="MuiMenuItem-root"]'), d = ({ inputs: l, stepIndex: s }) => {
+  l.forEach((e, a) => {
+    const o = i(s).find(r(e.typeElement)).eq(e?.index ?? a);
+    switch (e.valueVisibleByDefault && o.should("have.value", e.valueVisibleByDefault), e.typeElement) {
+      case "input":
+        if (e.typeValue === "number") {
+          const t = "text string testing";
+          o.type(t).should("not.have.value", t);
+        }
+        e.valueToWrite && o.should("be.visible").click().type(e.valueToWrite).should("have.value", e.valueToWrite);
+        break;
+      case "textarea":
+        e.valueToWrite && o.should("be.visible").click().type(e.valueToWrite);
+        break;
+      case "select":
+        if (o.should("be.visible").click(), e.endpointToWait && cy.wait(e.endpointToWait), e.options) {
+          for (let t = 0; t < e.options.length; t++)
+            c(o).eq(t).should("contain.text", e.options?.[t]);
+          c(o).eq(e.optionIndexToSelect ?? 0).click(), i(s).find("input").eq(e?.index ?? a).should("have.value", e.options?.[0]);
+        }
+        break;
+    }
+  });
+};
+export {
+  d as f
+};

package/e2e/commands/components/Form/cypress/fillAndAssertFormFields/type.d.ts

@@ -0,0 +1,5 @@
+import { InputsForm } from '../assertInitialFormState/type';
+export interface FillAndAssertFormFields {
+    inputs: InputsForm[];
+    stepIndex?: number;
+}

package/e2e/commands/components/Form/cypress/fillAndAssertFormFields/type.js

@@ -0,0 +1 @@
+

package/e2e/commands/components/Form/cypress/getFormScope/getFormScope.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Function to get the scope of the form based on the step index (if provided)
+ * or the whole form if no step index is provided
+ * @param stepIndex - The step index to get the scope of the form
+ * @returns The scope of the form. Examples:
+ * - Example with stepper:
+ * ```ts
+ * cy.get('[class*="M4LWindowBase-contentWindowBase"]')
+ * .find('[class*="M4LStepper-contentArea"]')
+ * .find('[class*="M4LStepper-stepContent"]')
+ * .eq(1)
+ * .find('[class*="M4LPaperForm-containerContent"]');
+ * ```
+ * - Example without stepper:
+ * ```ts
+ * cy.get('[class*="M4LWindowBase-contentWindowBase"]')
+ * .find('[class*="M4LPaperForm-containerContent"]');
+ * ```
+ */
+export declare const getFormScope: (stepIndex?: number) => Cypress.Chainable<JQuery<HTMLElement>>;

package/e2e/commands/components/Form/cypress/getFormScope/getFormScope.js

@@ -0,0 +1,8 @@
+import { W as o, P as s } from "../constants.js";
+const r = (t) => {
+  let e = cy.get(o);
+  return t !== void 0 && (e = e.find('[class*="M4LStepper-contentArea"]').find('[class*="M4LStepper-stepContent"]').eq(t)), e.find(s);
+};
+export {
+  r as g
+};

package/e2e/commands/components/Form/cypress/proceedFormStep/proceedFormStep.d.ts

@@ -0,0 +1,10 @@
+import { ProceedFormStep } from './type';
+/**
+ * Function to proceed to the next step or submit the form by clicking the button with the given label
+ * @param buttonLabel - The label of the button to click
+ * @param force - The force to click the button if true, the button will be clicked with force
+ * @returns The click action of the button with the given label
+ * @example
+ * cy.proceedFormStep({ buttonLabel: 'N_D:[stepper.label_next_button]', force: false });
+ */
+export declare const proceedFormStep: ({ buttonLabel, force }: ProceedFormStep) => void;

package/e2e/commands/components/Form/cypress/proceedFormStep/proceedFormStep.js

@@ -0,0 +1,6 @@
+const o = ({ buttonLabel: e, force: s = !1 }) => {
+  cy.get('[class*="M4LAreasViewer-windowBase"]').should("be.visible"), cy.get('[data-testid="M4LTypography-root"]').contains(e).should("be.visible").click({ force: s });
+};
+export {
+  o as p
+};

package/e2e/commands/components/Form/cypress/proceedFormStep/type.d.ts

@@ -0,0 +1,13 @@
+export interface ProceedFormStep {
+    /**
+     * The label of the button to click
+     * @example
+     * 'N_D:[stepper.label_next_button]'
+     */
+    buttonLabel: string;
+    /**
+     * The force to click the button if true, the button will be clicked with force
+     * @default false
+     */
+    force?: boolean;
+}

package/e2e/commands/components/Form/helpers/getFieldNameDomElement.d.ts

@@ -0,0 +1,7 @@
+import { InputsForm } from '../cypress/assertInitialFormState/type';
+/**
+ * Function to get the name of the DOM element based on the type of the element
+ * @param typeElement - The type of the element
+ * @returns The name of the DOM element
+ */
+export declare const getFieldNameDomElement: (typeElement: InputsForm["typeElement"]) => "input" | "textarea";

package/e2e/commands/components/Form/helpers/getFieldNameDomElement.js

@@ -0,0 +1,13 @@
+const t = (e) => {
+  switch (e) {
+    case "input":
+      return "input";
+    case "select":
+      return "input";
+    case "textarea":
+      return "textarea";
+  }
+};
+export {
+  t as g
+};

package/e2e/commands/components/Form/types.d.ts

@@ -0,0 +1,88 @@
+import { AssertInitialFormState } from './cypress/assertInitialFormState/type';
+import { AssertMandatoryFields } from './cypress/assertMandatoryFields/type';
+import { ProceedFormStep } from './cypress/proceedFormStep/type';
+import { FillAndAssertFormFields } from './cypress/fillAndAssertFormFields/type';
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Assert initial state of a Form, with or without stepper.
+       * You need send the params with the inputs to validate.
+       * @example
+       * // Option 1: Without stepper
+       * cy.m4lAssertInitialFormState({
+       *   inputs: [{ typeElement: 'input', index: 0, expectedValue: 'John Doe' }],
+       * });
+       * // Option 2: With stepper
+       * cy.m4lAssertInitialFormState({
+       *   steps: [{ stepperIndex: 1, inputs: [{ typeElement: 'input', index: 0, expectedValue: 'John Doe' }] }],
+       * });
+       */
+      m4lAssertInitialFormState (params: AssertInitialFormState): Chainable<void>
+      /**
+       * function to assert mandatory fields
+       * @param props - The properties to assert mandatory fields
+       * @example
+       * {
+       *   formFieldItems: [
+       *     {
+       *       name: 'name',
+       *       evaluateField: true,
+       *       mandatory: true,
+       *     },
+       *   ],
+       *   propertyValueSelector: '[data-testid="m4l-property-value-root-name"]',
+       * }
+       */
+      m4lAssertMandatoryFields (params: AssertMandatoryFields): Chainable<void>
+      /**
+       * Function to get the scope of the form based on the step index (if provided)
+       * or the whole form if no step index is provided
+       * @param stepIndex (optional) - The step index to get the scope of the form
+       * @returns The scope of the form. Examples:
+       * - Example with stepper:
+       * ```ts
+       * cy.get('[class*="M4LWindowBase-contentWindowBase"]')
+       * .find('[class*="M4LStepper-contentArea"]')
+       * .find('[class*="M4LStepper-stepContent"]')
+       * .eq(1)
+       * .find('[class*="M4LPaperForm-containerContent"]');
+       * ```
+       * - Example without stepper:
+       * ```ts
+       * cy.get('[class*="M4LWindowBase-contentWindowBase"]')
+       * .find('[class*="M4LPaperForm-containerContent"]');
+       * ```
+       */
+      m4lGetFormScope (stepIndex?: number): Chainable<JQuery<HTMLElement>>
+      /**
+       * Fill and validate the inputs of the form with the data of the form
+       * @param inputs - The inputs to validate
+       * @param stepIndex - The step index to get the scope of the form
+       * @returns Chainable<void>
+       * @example
+       * cy.m4lFillAndAssertFormFields({
+       *   inputs: [
+       *     { typeElement: 'input', index: 0, valueToWrite: 'John Doe' },
+       *     { typeElement: 'textarea', index: 0, valueToWrite: 'John Doe' },
+       *     { typeElement: 'select', index: 0, options: ['Option 1', 'Option 2'], optionIndexToSelect: 0, endpointToWait: '@getOptions' },
+       *   ],
+       *   stepIndex: 1,
+       * });
+       */
+      m4lFillAndAssertFormFields (params: FillAndAssertFormFields): Chainable<void>
+      /**
+       * Function to proceed to the next step or submit the form by clicking the button with the given label
+       * @param buttonLabel - The label of the button to click
+       * @param force - The force to click the button if true, the button will be clicked with force
+       * @returns Chainable<void>
+       * @example
+       * cy.proceedFormStep({ buttonLabel: 'N_D:[stepper.label_next_button]', force: false });
+       */
+      m4lProceedFormStep (params: ProceedFormStep): Chainable<void>
+    }
+  }
+}
+
+export { };

package/e2e/commands/components/MenuActions/commands.d.ts

@@ -1,4 +1,4 @@
 /**
- * Registra los comandos de MenuActions
+ * Registers MenuActions commands
  */
 export declare const registerMenuActionsCommands: () => void;

package/e2e/commands/components/MenuActions/commands.js

@@ -1,6 +1,6 @@
 const o = () => {
-  Cypress.Commands.add("m4lMenuActionsItem", (e) => {
-    cy.m4lPopover().find("[role=menuitem]").eq(e).should("be.visible", { timeout: 1e4 });
+  Cypress.Commands.add("m4lMenuActionsItem", (e, s) => {
+    cy.m4lPopover().find("[role=menuitem]").eq(e), s ? cy.should("have.attr", "aria-disabled", "true") : cy.should("be.visible", { timeout: 1e4 });
   });
 };
 export {

package/e2e/commands/components/MenuActions/types.d.ts

@@ -1,7 +1,22 @@
 declare global {
   namespace Cypress {
     interface Chainable {
-      m4lMenuActionsItem(menuItemIndex: number): Chainable<Element>
+      /**
+       * Gets the MenuItem of a MenuAction at the specified position. Optionally asserts disabled state.
+       * @example
+       * cy.m4lMenuActionsItem(0); // first item, expect visible
+       * cy.m4lMenuActionsItem(1, 'isDisabled'); // second item, expect disabled
+       */
+      m4lMenuActionsItem(
+        /**
+         * menuActions item index
+         */
+        menuItemIndex: number,
+        /**
+         * Indicates whether the menuActions item is disabled
+         */
+        isDisabled?: 'isDisabled',
+      ): Chainable<Element>
     }
   }
 }

package/e2e/commands/components/Popover/commands.d.ts

@@ -1,4 +1,4 @@
 /**
- * Registra los comandos de Popover
+ * Registers Popover commands
  */
 export declare const registerPopoverCommands: () => void;

package/e2e/commands/components/Popover/types.d.ts

@@ -1,6 +1,12 @@
 declare global {
   namespace Cypress {
     interface Chainable {
+      /**
+       * Gets the currently open popover (MUI Paper with role=presentation).
+       * @example
+       * cy.m4lDynamicFilterInputClick();
+       * cy.m4lPopover().find('li').contains('Name').click();
+       */
       m4lPopover(): Chainable<Element>
     }
   }

package/e2e/commands/components/PropertyValue/commands.d.ts

@@ -1,4 +1,4 @@
 /**
- * Registra los comandos de PropertyValue
+ * Registers PropertyValue commands
  */
 export declare const registerPropertyValueCommands: () => void;

package/e2e/commands/components/PropertyValue/types.d.ts

@@ -2,11 +2,16 @@ declare global {
   namespace Cypress {
     interface Chainable {
       /**
-       * Obtiene el PropertyValue
-       * @param selector selector de la propiedad
-       * @returns el valor de la propiedad
+       * Gets the PropertyValue element (value part) within the given selector.
+       * @example
+       * cy.m4lPropertyValue('[class*="M4LPropertyValue-root"]').should('have.text', '123');
        */
-      m4lPropertyValue(selector: string): Chainable<Element>
+      m4lPropertyValue(
+        /**
+         * Property selector
+         */
+        selector: string,
+      ): Chainable<Element>
     }
   }
 }

package/e2e/commands/components/Tab/commands.d.ts

@@ -1,4 +1,4 @@
 /**
- * Registra los comandos de Tab
+ * Registers Tab commands
  */
 export declare const registerTabCommands: () => void;

package/e2e/commands/components/Tab/commands.js

@@ -1,6 +1,7 @@
 const a = () => {
-  Cypress.Commands.add("m4lTabButton", (t, s) => {
-    cy.get(t).find("[role=tablist]").find("button").eq(s);
+  Cypress.Commands.add("m4lTabButton", (o, s, t) => {
+    const n = cy.get(o).find("[role=tablist]").find("button").eq(s);
+    t !== void 0 && n.should("have.text", t);
   });
 };
 export {

package/e2e/commands/components/Tab/types.d.ts

@@ -2,11 +2,26 @@ declare global {
   namespace Cypress {
     interface Chainable {
       /**
-       * Obtiene el botón de la pestaña indicada
-       * @param tabIndex índice de la pestaña a obtener
-       * @returns el botón de la pestaña indicada
+       * Gets the tab button at the given index and asserts its text equals tabTitle.
+       * @example
+       * cy.m4lTabButton('[class*="M4LTab-root"]', 0); // Without title
+       * cy.m4lTabButton('[class*="M4LTab-root"]', 0, 'Details');
+       * cy.m4lTabButton('[class*="M4LTab-root"]', 1, 'History');
        */
-      m4lTabButton(selector: string, tabIndex: number): Chainable<Element>
+      m4lTabButton(
+        /**
+         * @param selector - The component selector to get the tab button
+         */
+        selector: string,
+        /**
+         * @param tabIndex - The tab index to get the button
+         */
+        tabIndex: number,
+        /**
+         * @param tabTitle - The tab title to validate
+         */
+        tabTitle?: string,
+      ): Chainable<Element>
     }
   }
 }

package/e2e/commands/components/WindowBase/commands.d.ts

@@ -1,4 +1,4 @@
 /**
- * Registra los comandos de WindowBase
+ * Registers WindowBase commands
  */
 export declare const registerWindowBaseCommands: () => void;

package/e2e/commands/components/WindowBase/commands.js

@@ -1,16 +1,24 @@
-const a = () => {
+const e = () => {
   Cypress.Commands.add("m4lWindowBaseHeader", () => {
     cy.get('[class^="M4LDragResizeWindowRND-draggableHandle"]').find('[class^="M4LDragResizeWindowRND-draggableCancel"]');
-  }), Cypress.Commands.add("m4lWindowBaseLeftAction", (e) => {
-    cy.m4lWindowBaseHeader().find("button").eq(e);
-  }), Cypress.Commands.add("m4lWindowBaseLeftActionClick", (e) => {
-    cy.m4lWindowBaseLeftAction(e).click({ force: !0 });
-  }), Cypress.Commands.add("m4lWindowBaseMenuAction", (e) => {
-    cy.m4lWindowBaseHeader().find('[class*="M4LMenuActions-root-M4LWindowBase-menuActionsWindowBase"]').find("button").eq(0).click(), cy.get("[role=presentation]").find('[class^="MuiPaper-root"]').find("[role=menuitem]").eq(e);
-  }), Cypress.Commands.add("m4lWindowBaseMenuActionDisabled", (e) => {
-    cy.m4lWindowBaseMenuAction(e).should("have.attr", "aria-disabled", "true");
+  }), Cypress.Commands.add("m4lWindowBaseLeftAction", (s) => {
+    cy.m4lWindowBaseHeader().find("button").eq(s);
+  }), Cypress.Commands.add("m4lWindowBaseLeftActionClick", (s) => {
+    cy.m4lWindowBaseLeftAction(s).click({ force: !0 });
+  }), Cypress.Commands.add("m4lWindowBaseMenuAction", (s) => {
+    cy.m4lWindowBaseHeader().find('[class*="M4LMenuActions-root-M4LWindowBase-menuActionsWindowBase"]').find("button").eq(0).click(), cy.get("[role=presentation]").find('[class^="MuiPaper-root"]').find("[role=menuitem]").eq(s);
+  }), Cypress.Commands.add("m4lWindowBaseMenuActionDisabled", (s) => {
+    cy.m4lWindowBaseMenuAction(s).should("have.attr", "aria-disabled", "true");
+  }), Cypress.Commands.add("m4lDialogWindowActions", (s) => {
+    cy.get('[class^="MuiDialog-container"]').find('[class^="M4LWindowBase-root"]').should("contain", s);
+  }), Cypress.Commands.add("m4lDialogWindowActionsValidateTitle", (s) => {
+    cy.get('[class^="M4LGridLayout-root"]').find('[class*="M4LPopupsViewer-root"]').find('[class*="M4LDragResizeWindowRND-draggableHandle"]').find('[class*="M4LTypography-root"]').should("have.text", s);
+  }), Cypress.Commands.add("m4lAssertModuleHeaderTitle", (s) => {
+    cy.get('[class*="M4LWindowBase-root"]').find('[class*="M4LWindowBase-headerContentWindowBase"]').find('[class*="M4LWindowBase-containerTitleSubtitle"]').should("be.visible").should("contain.text", s);
+  }), Cypress.Commands.add("m4lAssertModuleHeaderIcon", (s) => {
+    cy.get('[class*="M4LWindowBase-root"]').find('[class*="M4LWindowBase-headerContentWindowBase"]').find('[class*="M4LIcon-root"]').find('[class*="M4LIcon-icon"]').should("be.visible").invoke("css", "mask").should("contain", s);
   });
 };
 export {
-  a as r
+  e as r
 };