@m4l/testing 0.0.24 → 1.0.1

package/types/packages/testing/vitest/src/helpers/elementMocks.d.ts

@@ -0,0 +1,166 @@
+import React from 'react';
+import type { PropsWithChildren } from '../types';
+type PaperFormProps = PropsWithChildren & {
+    title?: unknown;
+};
+type NamedFieldProps = {
+    name?: unknown;
+};
+type PropertyValueProps = {
+    property?: unknown;
+};
+type IconProps = {
+    src?: unknown;
+};
+type DividerProps = {
+    orientation?: unknown;
+    customVariant?: unknown;
+};
+type NavLinkProps = {
+    text?: React.ReactNode;
+    to?: unknown;
+    children?: React.ReactNode;
+    reloadDocument?: unknown;
+    [key: string]: unknown;
+};
+type ActionButtonMockOptions = {
+    testId: string;
+    disabledProp?: string;
+    handlerProp?: string;
+    labelProp?: string;
+};
+type WindowBaseProps = PropsWithChildren & {
+    title?: unknown;
+    onClose?: () => void;
+};
+type HelmetPageProps = PropsWithChildren & {
+    title?: unknown;
+    titlePrefix?: unknown;
+    subtitle?: unknown;
+};
+/**
+ * Creates a component mock that renders a `div` wrapper and preserves its
+ * children.
+ *
+ * Use this for layout-like component mocks where tests still need descendant
+ * rendering to stay visible in the DOM.
+ */
+export declare function createChildrenDivComponentMock(testId: string): import("vitest").Mock<({ children, ...props }: PropsWithChildren) => React.ReactElement<{
+    'data-testid': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a component mock that renders a static `div` with optional text.
+ *
+ * Use this when the collaborator only needs to exist as a simple placeholder
+ * in the DOM and does not need to render child content.
+ */
+export declare function createStaticDivComponentMock(testId: string, text?: string): import("vitest").Mock<() => React.ReactElement<{
+    'data-testid': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a `PaperForm` placeholder that keeps children mounted and captures
+ * the translated title as a stable test attribute.
+ */
+export declare function createPaperFormComponentMock(testId?: string): import("vitest").Mock<({ children, title }: PaperFormProps) => React.ReactElement<{
+    'data-testid': string;
+    'data-title': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a container placeholder that preserves children without forwarding
+ * arbitrary layout props to the DOM.
+ */
+export declare function createChildrenContainerComponentMock(testId: string): import("vitest").Mock<({ children }: PropsWithChildren) => React.ReactElement<{
+    'data-testid': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a `HelmetPage` placeholder that preserves children and exposes the
+ * received title metadata through stable DOM attributes.
+ *
+ * Use this in app-level test baselines when tests need to assert that page
+ * title props were forwarded correctly through `HelmetPage`.
+ */
+export declare function createHelmetPageComponentMock(testId?: string): import("vitest").Mock<({ children, subtitle, title, titlePrefix }: HelmetPageProps) => React.ReactElement<{
+    'data-testid': string;
+    'data-title': string;
+    'data-title-prefix': string;
+    'data-subtitle': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a field placeholder that exposes the bound RHF name through the
+ * generated test id.
+ */
+export declare function createNamedFieldComponentMock(prefix: string): import("vitest").Mock<({ name }: NamedFieldProps) => React.ReactElement<{
+    'data-testid': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a `PropertyValue` placeholder that exposes the property label
+ * through the generated test id.
+ */
+export declare function createPropertyValueComponentMock(prefix?: string): import("vitest").Mock<({ property }: PropertyValueProps) => React.ReactElement<{
+    'data-testid': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a lightweight `Icon` placeholder that records the source URL on a
+ * stable DOM attribute.
+ */
+export declare function createIconComponentMock(attributeName?: string): import("vitest").Mock<({ src }: IconProps) => React.DetailedReactHTMLElement<{
+    [attributeName]: string;
+}, HTMLElement>>;
+/**
+ * Creates a lightweight divider placeholder that exposes common visual props
+ * through stable DOM attributes.
+ */
+export declare function createDividerComponentMock(testId?: string): import("vitest").Mock<({ customVariant, orientation }: DividerProps) => React.ReactElement<{
+    'data-testid': string;
+    'data-orientation': string;
+    'data-variant': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a lightweight navigation-link placeholder that renders as a real
+ * anchor while keeping the API used by M4L component consumers.
+ */
+export declare function createNavLinkComponentMock(testId?: string): import("vitest").Mock<({ children, reloadDocument, text, to, ...props }: NavLinkProps) => React.ReactElement<{
+    'data-testid': string;
+    href: string;
+    'data-reload-document': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a window-shell placeholder that preserves children, exposes the
+ * received title through a stable test attribute, and forwards the close
+ * callback through a standard button.
+ */
+export declare function createWindowBaseComponentMock(testId?: string): import("vitest").Mock<({ children, onClose, title }: WindowBaseProps) => React.ReactElement<{
+    'data-testid': string;
+    'data-title': string;
+}, string | React.JSXElementConstructor<any>>>;
+/**
+ * Creates a simple button-like mock that forwards label, disabled, and click
+ * handling through configurable prop keys.
+ */
+export declare function createActionButtonComponentMock({ testId, disabledProp, handlerProp, labelProp, }: ActionButtonMockOptions): import("vitest").Mock<(props: Record<string, unknown>) => React.DetailedReactHTMLElement<{
+    'data-testid': string;
+    disabled: boolean;
+    onClick: (() => void) | undefined;
+}, HTMLElement>>;
+/**
+ * Creates a `Loadable`-style mock implementation that renders the wrapped
+ * component inside `React.Suspense` and exposes stable test ids for both the
+ * wrapper and fallback.
+ *
+ * Use this when a test needs the app-level `@m4l/components` baseline from
+ * `test/setup.ts`, but the subject imports lazy routes or another
+ * suspense-aware component through `Loadable`. Prefer overriding the shared
+ * `Loadable` mock with this helper through `vi.mocked(Loadable)` instead of
+ * re-declaring the entire `@m4l/components` module mock in the test file.
+ */
+export declare function createSuspenseLoadableComponentMock(testId: string, fallbackTestId?: string): import("vitest").Mock<(Component: React.ElementType) => () => React.FunctionComponentElement<React.SuspenseProps>>;
+/**
+ * Creates a neutral DataGrid-column hook mock that preserves the input props
+ * for later assertions.
+ *
+ * Use this in module-mock factories when the real grid column helpers are not
+ * under test but downstream code still expects formatter, filter, and sort
+ * members to exist.
+ */
+export declare function createDataGridColumnHookMock(): unknown;
+export {};

package/types/packages/testing/vitest/src/helpers/filterFields.d.ts

@@ -0,0 +1,37 @@
+import type { ReactElement } from 'react';
+/**
+ * Minimal structural shape for a DynamicFilter field used by shared test
+ * helpers.
+ */
+export interface TestingFilterFieldShape {
+    name: string;
+    dictionaryId?: string;
+    type: string;
+    multiple?: boolean;
+    presence?: string;
+    urlIcon?: string | ReactElement;
+    icon?: ReactElement;
+    defaultOperator?: unknown;
+    restritcOperatorsTo?: unknown;
+    defaultOperand1?: unknown;
+    selectAsyncOptions?: Record<string, unknown>;
+}
+/**
+ * Asserts that each filter field in `actualFields` matches the shape in
+ * `expectedFields`.
+ *
+ * Returns an array of human-readable violation strings. An empty array means
+ * all fields satisfy the contract. Pass the result to
+ * `expect(violations).toEqual([])`.
+ *
+ * Checks per field: `name`, `dictionaryId`, `type`, `multiple`, `presence`,
+ * `defaultOperator` (when present), `restritcOperatorsTo` (when present),
+ * `defaultOperand1` (when present), `urlIcon` (when present). For
+ * `selectAsync` fields, also verifies that `selectAsyncOptions` is defined and
+ * structurally matches the expected object.
+ *
+ * @param actualFields - The actual filter field array from the component or hook.
+ * @param expectedFields - The expected filter field array to compare against.
+ * @returns Array of violation strings; empty when all fields satisfy the contract.
+ */
+export declare function assertFilterFields(actualFields: TestingFilterFieldShape[], expectedFields: TestingFilterFieldShape[]): string[];

package/types/packages/testing/vitest/src/helpers/index.d.ts

@@ -0,0 +1,9 @@
+export * from './columnConfigs';
+export * from './elementMocks';
+export * from './filterFields';
+export * from './rhf';
+export * from './serialization';
+export * from './sortFields';
+export * from './mapStore';
+export * from './moduleContract';
+export * from './windowSizes';

package/types/packages/testing/vitest/src/helpers/mapStore.d.ts

@@ -0,0 +1,9 @@
+import type { UnknownRecord } from '../types';
+/**
+ * Builds the minimal map-store state needed by the shared `@m4l/gclick` mock.
+ *
+ * Use this as the starting point when a test needs `useMapStore()` to expose
+ * standard map actions but the real `@m4l/gclick` map store behavior is not
+ * the focus.
+ */
+export declare function createDefaultM4lPackageGclickMapStoreState(): UnknownRecord;

package/types/packages/testing/vitest/src/helpers/moduleContract.d.ts

@@ -0,0 +1,15 @@
+export type ModuleExportContractKind = 'callable' | 'value';
+/**
+ * Classifies a module export using the coarse runtime contract needed by
+ * shared mock drift tests.
+ */
+export declare function getModuleExportContractKind(value: unknown): ModuleExportContractKind;
+/**
+ * Returns mocked keys that no longer exist in the real module export surface.
+ */
+export declare function getMissingModuleMockExports(mockExports: Record<string, unknown>, realModule: Record<string, unknown>): string[];
+/**
+ * Returns human-readable kind mismatches between a mock surface and the real
+ * module export surface.
+ */
+export declare function getModuleMockKindMismatches(mockExports: Record<string, unknown>, realModule: Record<string, unknown>): string[];

package/types/packages/testing/vitest/src/helpers/rhf.d.ts

@@ -0,0 +1,8 @@
+import type { RHFSubmitRef } from '../types';
+/**
+ * Reads the shared RHF submit ref installed by `installRhfOnSubmitRef(...)`.
+ *
+ * Use this inside module-mock factories or assertions that need to wire a mock
+ * submit callback through a stable global slot.
+ */
+export declare function getRHFSubmitRef(globalKey?: string): RHFSubmitRef | undefined;

package/types/packages/testing/vitest/src/helpers/serialization.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Serializes viewer payloads into a deterministic string for simple DOM mocks.
+ *
+ * Use this when a component mock only needs to expose JSON-like content for
+ * assertions and the exact viewer implementation is outside the test scope.
+ */
+export declare function stringifyViewerData(data?: unknown): string;

package/types/packages/testing/vitest/src/helpers/sortFields.d.ts

@@ -0,0 +1,28 @@
+import type { ReactElement } from 'react';
+/**
+ * Minimal structural shape for a DynamicSort field used by shared test helpers.
+ */
+export interface TestingSortFieldShape {
+    name: string;
+    dictionaryId?: string;
+    type: string;
+    presence?: string;
+    urlIcon?: string | ReactElement;
+    icon?: ReactElement;
+}
+/**
+ * Asserts that each sort field in `actualFields` matches the shape in
+ * `expectedFields`.
+ *
+ * Returns an array of human-readable violation strings. An empty array means
+ * all fields satisfy the contract. Pass the result to
+ * `expect(violations).toEqual([])`.
+ *
+ * Checks per field: `name`, `dictionaryId`, `type`, `presence`, and `urlIcon`
+ * (when present).
+ *
+ * @param actualFields - The actual sort field array from the component or hook.
+ * @param expectedFields - The expected sort field array to compare against.
+ * @returns Array of violation strings; empty when all fields satisfy the contract.
+ */
+export declare function assertSortFields(actualFields: TestingSortFieldShape[], expectedFields: TestingSortFieldShape[]): string[];

package/types/packages/testing/vitest/src/helpers/windowSizes.d.ts

@@ -0,0 +1 @@
+export { M4L_APP_DATAGRID_SEMANTIC_WIDTHS, M4L_APP_WINDOW_SIZES, } from '../constants';

package/types/packages/testing/vitest/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './constants';
+export * from './fixtures';
+export * from './helpers';
+export * from './installers';
+export * from './factories';

package/types/packages/testing/vitest/src/installers/consoleError.d.ts

@@ -0,0 +1,9 @@
+import type { InstallConsoleErrorFilterOptions } from '../types';
+/**
+ * Installs a shared `console.error` filter for known noisy warnings.
+ *
+ * Use this in package or MF test setup when the suite has an intentional set
+ * of repeated warnings that would otherwise drown the useful failures. Keep
+ * the allowed patterns narrow and scenario-specific.
+ */
+export declare function installConsoleErrorFilter({ patterns, }: InstallConsoleErrorFilterOptions): void;

package/types/packages/testing/vitest/src/installers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './consoleError';
+export * from './rhfSubmit';

package/types/packages/testing/vitest/src/installers/rhfSubmit.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Installs a stable global submit ref used by shared RHF-based component
+ * mocks.
+ *
+ * Use this in MF `test/setup.ts` when the shared `RHFormProvider` mock should
+ * expose its submit callback through a predictable global ref for later test
+ * assertions.
+ */
+export declare function installRhfOnSubmitRef(globalKey?: string): void;

package/types/packages/testing/vitest/src/types.d.ts

@@ -0,0 +1,116 @@
+import type { EnvironmentFixture, HostToolsFixture, UserPreferencesFixture } from '../../mocks/src/index';
+import type React from 'react';
+export type UnknownRecord = Record<string, unknown>;
+export type VitestModuleMockExports = Record<string, unknown>;
+export type PropsWithChildren = {
+    children?: React.ReactNode;
+    [key: string]: unknown;
+};
+/**
+ * Describes the button-like props used by the shared `Button` test placeholder.
+ */
+export interface ButtonMockProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+    label?: React.ReactNode;
+    'data-testid'?: string;
+}
+/**
+ * Describes the button-like props used by the shared `IconButton` test placeholder.
+ */
+export interface IconButtonMockProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+}
+/**
+ * Describes the button-like props used by the shared `Tab` test placeholder.
+ */
+export interface TabMockProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+    label?: React.ReactNode;
+}
+/**
+ * Describes the reduced RHF provider contract used by the shared test placeholder.
+ */
+export interface RHFormProviderMockProps {
+    children?: React.ReactNode;
+    onSubmit?: () => void;
+    statusLoad?: string | null;
+}
+export type RHFSubmitRef = {
+    current: (() => void) | null;
+};
+export interface InstallConsoleErrorFilterOptions {
+    patterns: RegExp[];
+}
+export interface CreateVitestModuleMockOptions {
+    baseModule?: VitestModuleMockExports;
+    moduleOverrides?: VitestModuleMockExports;
+}
+export interface CreateM4lAppCoreModuleMockOptions<TBaseStoreState = UnknownRecord> extends CreateVitestModuleMockOptions {
+    baseStoreState?: TBaseStoreState;
+    environmentData?: Partial<EnvironmentFixture>;
+    hostToolsData?: HostToolsFixture;
+    moduleLabel?: string;
+    getLabel?: (key: string) => string;
+    userPreferencesData?: Partial<UserPreferencesFixture>;
+    authState?: {
+        isAuthenticated: boolean;
+        isInitialized: boolean;
+        user?: unknown;
+        login?: (...args: unknown[]) => object | undefined;
+        logout?: (...args: unknown[]) => Promise<void>;
+    };
+    flagsStoreState?: UnknownRecord;
+}
+export interface CreateM4lAppComponentsModuleMockOptions extends CreateVitestModuleMockOptions {
+    submitRefGlobalKey?: string;
+}
+export interface CreateM4lAppFormComponentsModuleOverridesOptions {
+    dynamicMFParameters?: UnknownRecord;
+}
+export interface CreateM4lAppFormLayoutsModuleOverridesOptions {
+    createComponentFieldImplementation?: (field: UnknownRecord) => unknown;
+}
+export interface CreateM4lBaseComponentsModuleMockOptions extends CreateVitestModuleMockOptions {
+    submitRefGlobalKey?: string;
+}
+export interface CreateM4lPackageCoreModuleMockOptions extends CreateVitestModuleMockOptions {
+    environmentData?: Partial<EnvironmentFixture>;
+    getLabel?: (key: string, value?: string) => string;
+    hostToolsData?: HostToolsFixture;
+    moduleLabel?: string;
+    modulePrivilegesData?: UnknownRecord;
+    networkData?: UnknownRecord;
+}
+export interface CreateM4lPackageComponentsModuleMockOptions extends CreateVitestModuleMockOptions {
+    dataGridPersistenceData?: UnknownRecord;
+    dynamicFilterAndSortData?: UnknownRecord;
+    modalData?: UnknownRecord;
+    popupsStoreData?: UnknownRecord;
+    windowToolsData?: UnknownRecord;
+}
+export type CreateM4lPackageBaseModuleMockOptions = CreateVitestModuleMockOptions;
+export type CreateM4lAppBaseModuleMockOptions = CreateVitestModuleMockOptions;
+export type CreateM4lPackageLayoutsModuleMockOptions = CreateVitestModuleMockOptions;
+export type CreateM4lPackageGraphicsModuleMockOptions = CreateVitestModuleMockOptions;
+export interface CreateM4lPackageGclickModuleMockOptions extends CreateVitestModuleMockOptions {
+    mapStoreState?: UnknownRecord;
+}
+export interface CreateM4lPackageGclickRealtimeModuleMockOptions extends CreateVitestModuleMockOptions {
+    surface?: 'root' | 'payload' | 'contracts';
+}
+export type CreateM4lAppGraphicsModuleMockOptions = CreateVitestModuleMockOptions;
+export type CreateM4lAppLayoutsModuleMockOptions = CreateVitestModuleMockOptions;
+export interface CreateReactLeafletModuleMockOptions extends CreateVitestModuleMockOptions {
+    useMapData?: unknown;
+    useMapImplementation?: () => unknown;
+}
+export interface CreateLeafletModuleMockOptions extends CreateVitestModuleMockOptions {
+    domEventData?: {
+        disableClickPropagation?: (target: HTMLElement) => void;
+        disableScrollPropagation?: (target: HTMLElement) => void;
+    };
+    scaleControlFactory?: () => unknown;
+}
+export interface CreateReactHookFormModuleMockOptions extends CreateVitestModuleMockOptions {
+    useFormContextData?: UnknownRecord;
+}

package/vitest/index.js

@@ -0,0 +1,55 @@
+import { D as o, a as t, M as c, f as s, v as r, y as M, s as l, k as n, h as i, u as k, z as p, p as d, l as u, o as m, P as C, G as g, H as F, J as A, I as P, N as S, K as E, L, O as R, Q as f, R as D, S as _, T as v, U as G, V as B, W as I, m as O, q as h, j as x, n as H, Y as T, X as y, Z as N, i as b, t as W, r as w, d as K, b as U, c as V, e as z, g as Y, B as Z, A as j, C as q, w as J, E as Q, F as X, x as $ } from "../chunks/reactLeaflet-Cffkauof.js";
+export {
+  o as DEFAULT_RHF_SUBMIT_REF_GLOBAL_KEY,
+  t as M4L_APP_DATAGRID_SEMANTIC_WIDTHS,
+  c as M4L_APP_WINDOW_SIZES,
+  s as assertColumnConfigs,
+  r as assertFilterFields,
+  M as assertSortFields,
+  l as createActionButtonComponentMock,
+  n as createChildrenContainerComponentMock,
+  i as createChildrenDivComponentMock,
+  k as createDataGridColumnHookMock,
+  p as createDefaultM4lPackageGclickMapStoreState,
+  d as createDividerComponentMock,
+  u as createHelmetPageComponentMock,
+  m as createIconComponentMock,
+  C as createLeafletModuleMock,
+  g as createM4lAppBaseModuleMock,
+  F as createM4lAppComponentsModuleMock,
+  A as createM4lAppCoreModuleMock,
+  P as createM4lAppFormComponentsModuleOverrides,
+  S as createM4lAppFormLayoutsModuleOverrides,
+  E as createM4lAppGraphicsModuleMock,
+  L as createM4lAppLayoutsModuleMock,
+  R as createM4lBaseComponentsModuleMock,
+  f as createM4lPackageBaseModuleMock,
+  D as createM4lPackageComponentsModuleMock,
+  _ as createM4lPackageCoreModuleMock,
+  v as createM4lPackageGclickModuleMock,
+  G as createM4lPackageGclickRealtimeModuleMock,
+  B as createM4lPackageGraphicsModuleMock,
+  I as createM4lPackageLayoutsModuleMock,
+  O as createNamedFieldComponentMock,
+  h as createNavLinkComponentMock,
+  x as createPaperFormComponentMock,
+  H as createPropertyValueComponentMock,
+  T as createReResizableModuleMock,
+  y as createReactHookFormModuleMock,
+  N as createReactLeafletModuleMock,
+  b as createStaticDivComponentMock,
+  W as createSuspenseLoadableComponentMock,
+  w as createWindowBaseComponentMock,
+  K as defaultM4lAppEnvironmentOverrides,
+  U as defaultM4lPackageEnvironmentOverrides,
+  V as distanceToNowFormatterFixture,
+  z as gclickGnssMotionStatusEnumFixture,
+  Y as gclickGnssSignalEnumFixture,
+  Z as getMissingModuleMockExports,
+  j as getModuleExportContractKind,
+  q as getModuleMockKindMismatches,
+  J as getRHFSubmitRef,
+  Q as installConsoleErrorFilter,
+  X as installRhfOnSubmitRef,
+  $ as stringifyViewerData
+};

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

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

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

@@ -1,19 +0,0 @@
-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

@@ -1,63 +0,0 @@
-/**
- * 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

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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 +0,0 @@
-/**
- * Registers DataGrid commands
- */
-export declare const registerDataGridCommands: () => void;