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

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

@@ -0,0 +1,4 @@
+/**
+ * Registers Accordions commands
+ */
+export declare const registerDynamicAccordionsCommands: () => void;

package/e2e/commands/components/Accordions/commands.js

@@ -0,0 +1,19 @@
+const t = () => {
+  Cypress.Commands.add(
+    "m4lDynamicAccordionsValidate",
+    (e, o, r, a) => {
+      cy.get('[class*="M4LAccordion-accordionRoot"]').eq(r).as("currentAccordion"), cy.get("@currentAccordion").find('[class*="M4LAccordion-accordionSummary"]').should("have.text", a).click(), cy.get("@currentAccordion").within(() => {
+        cy.get('[class*="MuiCollapse-hidden"]').should("exist");
+      }), cy.get("@currentAccordion").find('[class*="M4LAccordion-accordionSummary"]').click(), cy.get("@currentAccordion").within(() => {
+        cy.get('[class*="MuiCollapse-entered"]').should("exist");
+      }), e(o).forEach((c) => {
+        cy.get("@currentAccordion").find('[class*="M4LAccordion-accordionDetails"]').find('[role="property-value-form-role"]').eq(c.index).within(() => {
+          cy.log(`Validating name ${c.key}`), cy.get('[class*="M4LPropertyValue-name"]').should("have.text", c.key), cy.log(`Validating value ${c.value}`), cy.get('[role="property-value-value-role"][class*="M4LPropertyValue-value"]').should("contain.text", c.value);
+        });
+      });
+    }
+  );
+};
+export {
+  t as r
+};

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

@@ -0,0 +1,63 @@
+/**
+ * Property values accordion configuration
+ */
+export type M4lPropertyValuesAccordionsConfig = {
+  /**
+   * @param title - The accordion title
+   */
+  title: string;
+  /**
+   * @param key - The property key
+   */
+  key: string;
+  /**
+   * @param value - The property value
+   */
+  value: any;
+  /**
+   * @param index - The property index
+   */
+  index: number;
+};
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Validates the accordions using the dynamic accordions hook.
+       * Collapses/expands by title and checks each property key-value.
+       * @example
+       * const mockAccordions: M4lPropertyValuesAccordionsConfig[] = [
+       *   { title: 'Details', key: 'Name', value: 'Item 1', index: 0 },
+       *   { title: 'Details', key: 'Status', value: 'Active', index: 1 },
+       * ];
+       * cy.m4lDynamicAccordionsValidate(
+       *   (acc) => acc,
+       *   mockAccordions,
+       *   0,
+       *   'Details'
+       * );
+       */
+      m4lDynamicAccordionsValidate(
+        /**
+         * @param accordions - Function that returns the accordion configurations
+         */
+        accordions: (mockAccordions: M4lPropertyValuesAccordionsConfig[]) => M4lPropertyValuesAccordionsConfig[],
+        /**
+         * @param mockAccordions - The accordion configurations
+         */
+        mockAccordions: M4lPropertyValuesAccordionsConfig[],
+        /**
+         * @param index - The accordion index
+         */
+        index: number,
+        /**
+         * @param title - The accordion title
+         */
+        title: string,
+      ): Chainable<Element>;
+    }
+  }
+}
+
+export {};

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

@@ -0,0 +1,4 @@
+/**
+ * Registers CommonActions commands
+ */
+export declare const registerCommonActionsCommands: () => void;

package/e2e/commands/components/CommonActions/commands.js

@@ -0,0 +1,11 @@
+const n = () => {
+  Cypress.Commands.add(
+    "m4lConfirmActionIntro",
+    (o) => {
+      cy.get('[class*="M4LActionsContainer"]').should("contain", o).click();
+    }
+  );
+};
+export {
+  n as r
+};

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

@@ -0,0 +1,20 @@
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Finds the dialog action container, asserts it contains the option text, and clicks it.
+       * @example
+       * cy.m4lActionIntro('Accept');
+       * cy.m4lActionIntro('Cancel');
+       */
+      m4lConfirmActionIntro(
+        /**
+         * Button option
+         */
+        option: string,
+      ): Chainable<Element>;
+    }
+  }
+}
+
+export {};

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

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

package/e2e/commands/components/DataGrid/commands.js

@@ -1,42 +1,42 @@
-const u = () => {
-  Cypress.Commands.add("m4lDataGrid", (e) => {
-    cy.get(e).find('[class^="M4LDataGrid-root"]');
-  }), Cypress.Commands.add("m4lDataGridValidateVisibleColumns", (e, d, l, r = 1) => {
-    let a = 0, i = r;
-    d(l).forEach((n) => {
-      n.visible && (cy.log(`Validando columna visible: ${n.headerText} , index: ${i}`), i++, cy.m4lDataGrid(e).find("[role=row]").find(`[role=columnheader][aria-colindex=${i}]`).should("have.text", n.headerText), cy.m4lDataGrid(e).find("[role=row]").find(`[role=gridcell][aria-colindex=${i}]`).should("contain", n.value), cy.m4lDataGrid(e).find("[role=row]").find(`[role=columnheader][aria-colindex=${i}]`).then((s) => {
-        const o = s.width();
-        o !== void 0 && (a += o), cy.m4lDataGrid(e).find("[role=grid]").scrollTo(a, 0, { duration: 100, ensureScrollable: !1 });
+const f = () => {
+  Cypress.Commands.add("m4lDataGrid", (i) => cy.get(i).find('[class^="M4LDataGrid-root"]').filter(":visible").first()), Cypress.Commands.add("m4lDataGridValidateVisibleColumns", (i, n, a, o = 1) => {
+    let l = 0, t = o;
+    n(a).forEach((r) => {
+      r.visible && (cy.log(`Validating visible column: ${r.headerText} , index: ${t}`), t++, cy.m4lDataGrid(i).find("[role=row]").find(`[role=columnheader][aria-colindex=${t}]`).should("have.text", r.headerText), cy.m4lDataGrid(i).find("[role=row]").find(`[role=gridcell][aria-colindex=${t}]`).should("contain", r.value), cy.m4lDataGrid(i).find("[role=row]").find(`[role=columnheader][aria-colindex=${t}]`).then((s) => {
+        const d = s.width();
+        d !== void 0 && (l += d), cy.m4lDataGrid(i).find("[role=grid]").scrollTo(l, 0, { duration: 100, ensureScrollable: !1 });
       }));
     });
-  }), Cypress.Commands.add("m4lDataGridRow", (e, d, l) => {
-    let r = 0, a = 0;
-    const i = 10, n = d + 1;
+  }), Cypress.Commands.add("m4lDataGridRow", (i, n, a) => {
+    let o = 0, l = 0;
+    const t = 10, r = n + 1;
     function s() {
-      return cy.m4lDataGrid(e).find("[role=row]").not('[aria-rowindex="1"]').filter(`[aria-rowindex="${n}"]`).then((o) => {
-        if (o.length > 0) {
-          const t = o[0].getBoundingClientRect();
-          if (t.top >= 0 && t.left >= 0 && t.bottom <= (window.innerHeight || document.documentElement.clientHeight) && t.right <= (window.innerWidth || document.documentElement.clientWidth))
-            return cy.wrap(o);
+      return cy.m4lDataGrid(i).find("[role=row]").not('[aria-rowindex="1"]').filter(`[aria-rowindex="${r}"]`).then((d) => {
+        if (d.length > 0) {
+          const e = d[0].getBoundingClientRect();
+          if (e.top >= 0 && e.left >= 0 && e.bottom <= (window.innerHeight || document.documentElement.clientHeight) && e.right <= (window.innerWidth || document.documentElement.clientWidth))
+            return cy.wrap(d);
         }
-        if (a >= i)
-          throw new Error(`No se encontró la fila ${n} después de ${i} intentos`);
-        return a++, cy.m4lDataGrid(e).find("[role=row]").not('[aria-rowindex="1"]').filter((m, t) => {
-          const c = t.getBoundingClientRect();
+        if (l >= t)
+          throw new Error(`Row ${r} was not found after ${t} attempts`);
+        return l++, cy.m4lDataGrid(i).find("[role=row]").not('[aria-rowindex="1"]').filter((m, e) => {
+          const c = e.getBoundingClientRect();
           return c.top >= 0 && c.left >= 0 && c.bottom <= (window.innerHeight || document.documentElement.clientHeight) && c.right <= (window.innerWidth || document.documentElement.clientWidth);
         }).first().then((m) => {
-          const t = m.height() || 0;
-          return r += t, cy.m4lDataGrid(e).find("[role=grid]").scrollTo(0, r, { duration: 100, ensureScrollable: !1 }).then(() => s());
+          const e = m.height() || 0;
+          return o += e, cy.m4lDataGrid(i).find("[role=grid]").scrollTo(0, o, { duration: 100, ensureScrollable: !1 }).then(() => s());
         });
       });
     }
-    return s().find(`[role=gridcell][aria-colindex="${l}"]`);
-  }), Cypress.Commands.add("m4lDataGridRowAction", (e, d, l = 1, r = 1) => {
-    cy.m4lDataGridRow(e, l, r).find("button").eq(0).should("be.visible", { timeout: 1e4 }).click(), cy.m4lMenuActionsItem(d);
-  }), Cypress.Commands.add("m4lDataGridFindAllColumns", (e) => {
-    cy.m4lDataGrid(e).find('[class^="M4LDataGrid-actionsConfigContainer"]').find("button").eq(2).click();
+    return s().find(`[role=gridcell][aria-colindex="${a}"]`);
+  }), Cypress.Commands.add("m4lDataGridRowAction", (i, n, a = 1, o = 1) => {
+    cy.m4lDataGridRow(i, a, o).find("button").eq(0).should("be.visible", { timeout: 1e4 }).click(), cy.m4lMenuActionsItem(n);
+  }), Cypress.Commands.add("m4lDataGridFindAllColumns", (i) => {
+    cy.m4lDataGrid(i).find('[class^="M4LDataGrid-actionsConfigContainer"]').find("button").eq(2).click();
+  }), Cypress.Commands.add("m4lDataGridOrCardViewMode", (i, n) => {
+    cy.m4lDataGrid(i).find('[class*="M4LDataGrid-actionsConfigContainer"]').find('[class*="M4LDataGrid-containerLeftActions"]').find('button[aria-label="view-mode"]').click(), cy.get("[role=presentation]").find('[class^="MuiPaper-root"]').find("[role=button]").eq(n).click();
   });
 };
 export {
-  u as r
+  f as r
 };

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

@@ -1,53 +1,138 @@
-import { M4LGetCypressDataGridColumnsConfig } from './export';
+/**
+ * Column configuration for DataGrid in Cypress
+ */
+export type M4LDataGridCypressColumn = {
+  /**
+   * @param key - The column key
+   */
+  key: string;
+  /**
+   * @param value - The column value
+   */
+  value: any;
+  /**
+   * @param headerText - The column header text
+   */
+  headerText: string;
+  /**
+   * @param visible - Indicates whether the column is visible
+   */
+  visible: boolean;
+};
+
+/**
+ * Function that gets the DataGrid column configuration
+ */
+export type M4LGetCypressDataGridColumnsConfig<T> = (data: T) => M4LDataGridCypressColumn[];
+
 declare global {
   namespace Cypress {
     interface Chainable {
       /**
-       * Obtiene el grid
-       * @param selector selector del grid
-       * @returns el grid
+       * Gets the grid. Returns the first visible M4LDataGrid under the selector.
+       * @param selector grid selector
+       * @returns the grid
+       * @example
+       * cy.m4lDataGrid('[class*="M4LDataGrid-root"]').find('[role=row]').should('have.length.at.least', 1);
        */
-      m4lDataGrid(selector: string): Chainable<Element>
+      m4lDataGrid(selector: string ): Chainable<JQuery<HTMLElement>>
       /**
-       * Valida las columnas visibles del grid
-       * @param selector selector del grid
-       * @param getColumnsConfig función que obtiene las columnas visibles del grid
-       * @param mockData datos del grid
-       * @param baseColumnIndex índice de la columna a obtener
+       * Validates the visible columns of the grid. Scrolls horizontally as needed for each column.
+       * @example
+       * const getColumns = (data: MockItem) => [
+       *   { key: 'name', headerText: 'Name', value: data.name, visible: true },
+       *   { key: 'code', headerText: 'Code', value: data.code, visible: true },
+       * ];
+       * cy.m4lDataGridValidateVisibleColumns('[class*="M4LDataGrid-root"]', getColumns, mockItem, 1);
        */
       m4lDataGridValidateVisibleColumns<T>(
+        /**
+         * Grid selector
+         */
         selector: string,
+        /**
+         * Function that gets the visible columns of the grid
+         */
         getColumnsConfig: M4LGetCypressDataGridColumnsConfig<T>,
+        /**
+         * Grid data
+         */
         mockData: T,
+        /**
+         * Column index to get
+         */
         baseColumnIndex?: number
       ): Chainable<void>;
       /**
-       * Obtiene la fila del grid especificada por el índice de base 1, garantizando que esté visible en el viewport
-       * @param selector selector del grid
-       * @param targetRowBaseOneIndex índice de la fila a obtener
-       * @param baseOneColumnIndex índice de la columna a obtener
-       * @returns la fila del grid
+       * Gets the grid row specified by 1-based index, ensuring it is visible in the viewport.
+       * @example
+       * cy.m4lDataGridRow('[class*="M4LDataGrid-root"]', 2, 1).click(); // row 2, column 1
        */
-      m4lDataGridRow(selector: string, targetRowBaseOneIndex: number, baseOneColumnIndex: number): Chainable<JQuery<HTMLElement>>;
+      m4lDataGridRow(
+        /**
+         * Grid selector
+         */
+        selector: string,
+        /**
+         * Row index to get
+         */
+        targetRowBaseOneIndex: number,
+        /**
+         * Column index to get
+         */
+        baseOneColumnIndex: number
+      ): Chainable<JQuery<HTMLElement>>;
       /**
-       * Obtiene el rowAction del menuActions asociado a la fila del grid especificada por el índice de base 1
-       * @param selector selector del grid
-       * @param menuItemIndex índice del item del menuActions
-       * @param baseOneTargetRowIndex índice de la fila a obtener
-       * @param baseColbaseOneColumnIndexumnIndex índice de la columna a obtener
-       * @returns el rowAction del menuActions asociado a la fila del grid
+       * Opens the row actions menu for the given row and selects the menu item by index.
+       * @example
+       * cy.m4lDataGridRowAction('[class*="M4LDataGrid-root"]', 0, 2, 1); // row 2, column 1, first menu item
        */
       m4lDataGridRowAction(
+        /**
+         * Grid selector
+         */
         selector: string,
+        /**
+         * menuActions item index
+         */
         menuItemIndex: number,
+        /**
+         * Row index to get
+         */
         baseOnetargetRowIndex?: number,
+        /**
+         * Column index to get
+         */
         baseOneColumnIndex?: number,
       ): Chainable<Element>
 
       /**
-       * Busca y muestra todas las columnas del grid principal
+       * Finds and shows all columns of the main grid by opening the configurator (third button).
+       * @example
+       * cy.m4lDataGridFindAllColumns('[class*="M4LDataGrid-root"]');
+       */
+      m4lDataGridFindAllColumns(
+        /**
+         * Grid selector
+         */
+        selector: string,
+      ): Chainable<Element>
+      /**
+       * Switches the grid view mode (e.g. Card vs Grid). Clicks the view-mode button and selects option by index.
+       * @example
+       * cy.m4lDataGridViewMode('[class*="M4LDataGrid-root"]', 0);
+       * cy.m4lDataGridViewMode('[class*="M4LDataGrid-root"]', 1);
        */
-      m4lDataGridFindAllColumns(selector: string): Chainable<Element>
+      m4lDataGridOrCardViewMode(
+        /**
+         * Selector for the section to validate
+         */
+        section: string,
+        /**
+         * Card or Grid view mode
+         */
+        viewMode: number,
+      ): Chainable<Element>;
     }
   }
 }

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

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

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

@@ -2,15 +2,22 @@ declare global {
   namespace Cypress {
     interface Chainable {
       /**
-       * Click en el input de filtro
+       * Clicks on the filter input to open the filter popover.
+       * @example
+       * cy.m4lDynamicFilterInputClick();
+       * cy.m4lPopover().find('li').first().click();
        */
       m4lDynamicFilterInputClick(): Chainable<Element>;
       /**
-       * Aplicar el filtro de fecha
+       * Applies the date filter: opens filter input, selects the date field by label, then confirms.
+       * @example
+       * cy.m4lDynamicFilterApplyedDateField('Created at');
        */
       m4lDynamicFilterApplyedDateField(dateFieldLabel: string): Chainable<Element>;
       /**
-       * Obtiene el botón de refrescar
+       * Gets the refresh button (second button in the filter actions area).
+       * @example
+       * cy.m4lDynamicFilterRefreshButton('[class*="M4LSplitLayout-splitDetail"]').click();
        */
       m4lDynamicFilterRefreshButton(selector: string): Chainable<Element>;
     }

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

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

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

@@ -1,8 +1,24 @@
 declare global {
   namespace Cypress {
     interface Chainable {
+      /**
+       * Clicks on the sort input to open the sort popover.
+       * @example
+       * cy.m4lDynamicSortInputClick();
+       * cy.m4lPopover().find('li').contains('Name').click();
+       */
       m4lDynamicSortInputClick(): Chainable<Element>
-      m4lDynamicSortApplyedField(dateFieldLabel: string): Chainable<Element>
+      /**
+       * Applies the sort for a field: opens sort input, selects the field by label, then confirms.
+       * @example
+       * cy.m4lDynamicSortApplyedField('Created at');
+       */
+      m4lDynamicSortApplyedField(
+        /**
+         * Date field label
+         */
+        dateFieldLabel: string,
+      ): Chainable<Element>
     }
   }
 }

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

@@ -0,0 +1,4 @@
+/**
+ * Registers Filters and Sorts commands
+ */
+export declare const registerFiltersCommands: () => void;

package/e2e/commands/components/Filters/commands.js

@@ -0,0 +1,24 @@
+const I = '[class*="M4LSplitLayout-splitDetail"]', y = () => {
+  Cypress.Commands.add(
+    "m4lFiltersAndSortsOptionsValidation",
+    (i, t, n, s, c, l) => {
+      const o = () => cy.get('[role="presentation"]', { timeout: 1e3 }).should("exist"), r = (e) => {
+        o(), cy.get('[role="presentation"]', { timeout: 1e3 }).find("li").contains(e.key).click(), cy.get('[role="presentation"]', { timeout: 1e3 }).find('[class*="MuiPaper-root-MuiPopover-paper"]').should("be.visible").find("input").eq(e.inputIndex).click({ force: !0 });
+      }, T = () => {
+        cy.get("[role=presentation]").find("button").contains("N_D:[common_actions.intro]").click({ force: !0 });
+      }, d = (e) => {
+        ["select", "selectAsync", "boolean"].includes(e.type) ? (o(), cy.get('[role="presentation"]', { timeout: 1e3 }).find("li").eq(0).click({ force: !0 }), cy.get("[role=presentation]").find('[class*="MuiPaper-root-MuiPopover-paper"]').find('[class*="M4LWindowBase-headerWindowComponent"]').dblclick({ force: !0 })) : ["string", "number"].includes(e.type) && (o(), cy.get('[role="presentation"]', { timeout: 1e3 }).find("input").eq(1).type(e.value));
+      }, a = (e, p, u, E) => {
+        cy.log(`Validating filter ${e.key}`), cy.get(p, { timeout: 1e3 }).find(u).eq(E).click(), r(e), d(e), T();
+      };
+      i(t).forEach((e) => {
+        l ? (a(e, n, s, c), cy.get(`${I} [class*="M4LDynamicFilter-actions"] button`).eq(1).click(), cy.wait(e.endpoint, { timeout: 1e3 })) : (a(e, n, s, c), cy.wait(e.endpoint, { timeout: 1e3 }).wait("@getList", { timeout: 1e3 }));
+      });
+    }
+  ), Cypress.Commands.add("m4lFiltersAndSortsPersistValidation", (i, t, n) => {
+    cy.get(i).find(`[class*="M4LDynamic${t}-applied${t}s"]`).find(`[class*="M4LDynamic${t}-applied${t}InnerContainer"]`).find("[role=button-chip]").should("have.length", n);
+  });
+};
+export {
+  y as r
+};

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

@@ -0,0 +1,91 @@
+/**
+ * Filter and sort configuration for Filters
+ */
+export type M4lFiltersAndSortsConfig = {
+  /**
+   * Filter type for string, number, select, selectAsync and boolean types
+   */
+  type: string;
+  /**
+   * Filter key for select, selectAsync and boolean types
+   */
+  key: string;
+  /**
+   * Filter value for string and number types
+   */
+  value: string;
+  /**
+   * Filter endpoint to wait for
+   */
+  endpoint: string;
+  /**
+   * Filter input index
+   */
+  inputIndex: number;
+};
+
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Validates filter and sort options for DynamicFilter. For each filter, selects it, applies value by type, sends input.
+       * @example
+       * const mockFilters: M4lDynamicFilterConfig[] = [
+       *   { type: 'string', key: 'Name', value: 'test', endpoint: '@getList', inputIndex: 1 },
+       * ];
+       * cy.intercept('GET', '/api/items*').as('getList');
+       * cy.m4lDynamicFilterValidateFilterAndSortOptions(
+       *   (f) => f,
+       *   mockFilters,
+       *   '[class*="M4LDynamicFilter-root"]',
+       *   '[class*="M4LDynamicFilter-filterChip"]',
+       *   0
+       * );
+       */
+      m4lFiltersAndSortsOptionsValidation (
+        filters: (mockFilters: M4lFiltersAndSortsConfig[]) => M4lFiltersAndSortsConfig[],
+        /**
+         * Mock of the filters to validate
+         */
+        mockFilters: M4lFiltersAndSortsConfig[],
+        /**
+         * Selector for the filters or sort to validate
+         */
+        filtersOrSort: string,
+        /**
+         * Selector for the section to validate
+         */
+        section: string,
+        /**
+         * Index of the filters or sort to validate
+         */
+        index: number,
+        /**
+         * If true, validates the filter in the logs tab
+         */
+        logs?: boolean,
+      ): Chainable<Element>;
+      /**
+       * Asserts that the number of applied filter/sort chips matches the expected length.
+       * @example
+       * cy.m4lDynamicFilterAndSortsPersist('[class*="M4LSplitLayout-splitDetail"]', 'Filter', 2);
+       */
+      m4lFiltersAndSortsPersistValidation (
+        /**
+         * Selector for the section to validate
+         */
+        section: string,
+        /**
+         * Filter or sort type
+         */
+        type: 'Filter' | 'Sort',
+        /**
+         * Length of applied filters and sorts
+         */
+        length: number,
+      ): Chainable<Element>;
+    }
+  }
+}
+
+export { };

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

@@ -0,0 +1,4 @@
+/**
+ * Registers Form commands
+ */
+export declare const registerFormCommands: () => void;

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

@@ -0,0 +1,11 @@
+import { a as s } from "./cypress/assertInitialFormState/assertInitialFormState.js";
+import { a as r } from "./cypress/assertMandatoryFields/assertMandatoryFields.js";
+import { f as m } from "./cypress/fillAndAssertFormFields/fillAndAssertFormFields.js";
+import { g as o } from "./cypress/getFormScope/getFormScope.js";
+import { p as e } from "./cypress/proceedFormStep/proceedFormStep.js";
+const l = () => {
+  Cypress.Commands.add("m4lAssertInitialFormState", s), Cypress.Commands.add("m4lAssertMandatoryFields", r), Cypress.Commands.add("m4lGetFormScope", o), Cypress.Commands.add("m4lFillAndAssertFormFields", m), Cypress.Commands.add("m4lProceedFormStep", e);
+};
+export {
+  l as r
+};

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

@@ -0,0 +1,5 @@
+import { AssertInitialFormState } from './type';
+/**
+ * Assert initial state of a Form, with or without stepper.
+ */
+export declare const assertInitialFormState: (params: AssertInitialFormState) => void;

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

@@ -0,0 +1,20 @@
+import { W as n, D as c } from "../constants.js";
+import { g as d } from "../../helpers/getFieldNameDomElement.js";
+import { g as h } from "../getFormScope/getFormScope.js";
+const a = (e, o, t) => h(t).find(d(e.typeElement)).eq(e.index ?? o), i = (e, o) => {
+  e.forEach((t, s) => {
+    a(t, s, o).should("be.visible"), a(t, s, o).should("have.value", t.expectedValue ?? ""), t.enabled === !1 ? a(t, s, o).should("have.attr", "readonly") : a(t, s, o).should("not.have.attr", "readonly");
+  });
+}, f = (e) => "steps" in e, g = (e) => {
+  const { endpointToWait: o } = e;
+  if (o && cy.wait(o), cy.get(n).should("be.visible"), f(e)) {
+    const { steps: t, labelNextButton: s = c } = e;
+    t.sort((r, l) => r.stepperIndex - l.stepperIndex).forEach((r, l) => {
+      l > 0 && cy.contains('[data-testid="M4LTypography-root"]', s).should("be.visible").click(), i(r.inputs, r.stepperIndex);
+    });
+  } else
+    i(e.inputs);
+};
+export {
+  g as a
+};