@sumaris-net/ngx-components 21.0.0-rc2 → 21.0.0-rc20

package/doc/changelog.md

@@ -1,6 +1,5 @@
 # Change log
 
-
 ## 0.1.7
 
 - enh: Menu: Allow dynamic insertion, using a new config options (see 'CORE_CONFIG_OPTIONS.MENU_ITEMS')
@@ -2224,3 +2223,92 @@ enh: Environment: add useHash property to configure Angular router to use hash U
 
 ## 18.24.7
 - fix(menu): fix color in svg icon
+
+## 18.24.9
+- fix(platform) Fix version.appup parsing (avoid infinite loop when on '-alpha' versions)
+- enh(upload-popover) Allow overriding buttons text
+
+## 18.24.12
+- enh(images.utils) Add `ImagesUtils.writeBase64ToFile`
+
+## 18.24.14
+- enh(form.pipes): Add new pipes for accessing FormArray controls and groups
+- fix(dates) Fix fromDateISOString() when requiredTime and no millisecond given
+- test(validators): Add unit tests for `validDate` and `validDateAllowNoTime` validation methods
+
+## 18.24.18
+- fix(tab-editor) Fix event argument typing, in `AppTabEditor.onSwipeTab()`
+
+## 18.24.21
+- enh(table) Allow to define reserved columns (start and end) in `AsyncTable`
+
+## 18.24.22
+- fix(menu) Allow to hide the footer, on small screens
+
+## 18.24.23
+- fix(material.date) Prevent event propagation in `openDatePicker()`
+
+## 18.24.24
+- enh(FileUtils) Add more options to `showUploadPopover()` like `backdropDismiss`, `keyboardClose` and `translucent`.
+
+## 18.24.25
+- fix(platform) Let Capacitor config handle accessory bar
+
+## 18.25.0
+- enh(startup) Add a startup service to be able to automatically set the peer and authenticate user
+- enh(testing) Add a testing package for shared testing utilities
+
+## 18.25.1
+- fix(startup) Missing export symbols in public API
+
+## 18.25.3
+- fix(animations) Fix Chrome warning about non-animatable property `overflow` in `expansionAnimation`
+
+## 18.25.4
+- fix(AppAsyncTable) Add `logPrefix` property to allow customizing the logs prefix
+
+## 18.25.5
+- enh(mat-autocomplete-field) Add custom header and footer support for `mat-autocomplete-field`, using `<ng-template panelHeader>` and `<ng-template panelFooter>` 
+- enh(mat-autocomplete-field) Add new inputs `showPanelHeader` and `showPanelFooter` to hide defaults header/footer
+
+## 18.25.6
+- enh(gallery) Add `zoomPresentation` to display slideshow without modal, but inside the main container
+
+## 18.25.15
+- enh(gallery) Rename mouse zoom, rotate and crop options to `enableMouseZoom`, `enableRotate` and `enableCrop`
+- enh(gallery) Rename `zoomPresentation` into `slideshowMode`
+
+## 18.26.0
+- enh(icon-selector) New component suite for icon selection: `AppIconSelectorModal` (modal with tabs, search, badges) and `AppIconSelectorField` (form field with ControlValueAccessor)
+- enh(generate-icons) New `npm run generate:icons` script to generate `assets/icons-ref.json` from `node_modules` (ionicons + material-design-icons)
+
+## 21.0.0
+- enh(core) Migration to Angular 21 and Ionic 8
+- enh(e2e) Allow to run e2e on many peer/login, using file `e2e/.environments.json` or `.environments.json` (or `.local/environments.json`)
+- fix(Toolbar) Add subTitle input
+- fix(AuthForm): fix error message display
+- fix(UsersTable): fix error message display and use @if instead of @ngIf
+- enh(autocomplete): Add `showHeaderList` and `showFooterList` inputs to control header/footer visibility in dropdown
+- enh(autocomplete): Add `headerListTemplate` and `footerListTemplate` content projection slots for custom header/footer content
+- enh(about) Add changelog link (Notes de version) to About modal, using ConfigurationService and markdown modal
+- Breaking change: GraphqlService now driven by `APP_GRAPHQL_SERVICE` token, and provided by default with `CoreModule.forRoot()`; Removed from service constructors
+- Breaking change: Translate service updated to v18: the TranslateModule has been removed. Now use `provideTranslateService()` or `provideChildTranslateService()`
+- enh(GraphqlService): add `onExpiredAuth` subject to handle expired auth events, registered by account service.
+- enh(deps): apollo-link-queue and apollo-link-serialize deps removed. Replace by specific implementations
+- fix(ui): `ion-label` no longer supports `[innerHTML]` bindings (use text interpolation or `ion-text` instead)
+- fix(settings): prevent default event behavior in `showSelectPeerModal` (avoid the keyboard to appear, on mobile)
+- fix(android): fix Android build (upgrade Gradle wrapper to 8.14.5) and target SDK API 36
+- fix(android): fix Android keyboard issue (sumaris-app#2076) and refine EdgeToEdge / StatusBar compatibility for Android 15-17
+- fix(theme): add padding-inline fallback for Chrome < 87 compatibility
+- fix(app): fallback to `provideNoopAnimations()` if Web Animations API is unsupported
+- fix(utils:compat): add core-js compat imports and browserslist configuration
+- fix(core): ensure toast service waits for initialization before displaying
+- enh(about): generate changelog from GitLab release API
+- fix(table): waitWhilePending timeout handling in confirmEdit/confirmCreate (Mantis 69886)
+- enh(alerts): implement and expose options (`backdropDismiss`, `keyboardClose`) to callers
+- enh(upload-file): add check for maximum file size and blacklisted extensions
+- test(markdown): add unit tests for `MarkdownUtils` helper functions
+- fix(mat-date-time): fix timepicker dropdown popup position in desktop mode by attaching directive directly to the visible input
+- fix(animation) Fix warning in the JS console, on expansionAnimation
+- fix(settings-page) Local settings was always overridden by account settings - Fix issue sumaris-app#1755
+- fix(functions) cherrypick fixes on functions, from v18.x  

package/fesm2022/sumaris-net-ngx-components-testing.mjs

@@ -0,0 +1,502 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { test } from '@playwright/test';
+
+// Standalone startup constants for the testing package.
+// Must be kept in sync with src/app/core/services/startup.constants.ts
+const STARTUP_DATA_STORAGE_KEY = '__appStartupData';
+
+/**
+ * Utility selectors and helpers for Ionic components in e2e tests.
+ */
+const IonicSelectors = {
+    /** Ionic button */
+    button: 'ion-button',
+    /** Ionic modal */
+    modal: 'ion-modal',
+    /** Ionic content area */
+    content: 'ion-content',
+    /** Ionic item */
+    item: 'ion-item',
+    /** Ionic label */
+    label: 'ion-label',
+    /** Ionic spinner */
+    spinner: 'ion-spinner',
+    /** Ionic skeleton text (loading placeholder) */
+    skeletonText: 'ion-skeleton-text',
+    /** Ionic back button */
+    backButton: 'ion-back-button',
+    /** Ionic toolbar */
+    toolbar: 'ion-toolbar',
+    /** Ionic footer */
+    footer: 'ion-footer',
+    /** Ionic header */
+    header: 'ion-header',
+};
+/**
+ * Helper functions for interacting with Ionic components.
+ */
+class IonicHelper {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /** Get an Ionic button by text content */
+    buttonByText(text) {
+        return this.page.locator(IonicSelectors.button, { hasText: text });
+    }
+    /** Get an Ionic button by CSS selector */
+    button(selector, options) {
+        const fullSelector = selector ? `${IonicSelectors.button}${selector}` : IonicSelectors.button;
+        return this.page.locator(fullSelector, options);
+    }
+    /**
+     * Get an Ionic modal by its inner component selector (e.g. 'app-auth-form').
+     * Automatically wraps the selector in `ion-modal:has(...)` so callers
+     * only need to provide the component tag name.
+     */
+    modal(selector) {
+        const fullSelector = selector.startsWith('ion-modal') ? selector : `ion-modal:has(${selector})`;
+        return this.page.locator(fullSelector);
+    }
+    /** Wait for the Ionic app to be ready */
+    async waitForAppReady(timeout = 15_000) {
+        // Wait for ion-app to be attached (Angular bootstrap complete)
+        await this.page.waitForSelector('ion-app', { state: 'attached', timeout });
+    }
+    /** Wait for loading spinners to disappear */
+    async waitForLoadingComplete(timeout = 15_000) {
+        await this.page
+            .locator(IonicSelectors.spinner)
+            .waitFor({ state: 'hidden', timeout })
+            .catch(() => {
+            // Spinner may not appear at all — that's fine
+        });
+    }
+}
+
+/**
+ * Utility selectors and helpers for Angular Material components in e2e tests.
+ */
+const MaterialSelectors = {
+    /** Material table row */
+    row: 'mat-row, tr[mat-row]',
+    /** Material header row */
+    headerRow: 'mat-header-row, tr[mat-header-row]',
+    /** Material cell */
+    cell: 'mat-cell, td[mat-cell]',
+    /** Material form field */
+    formField: 'mat-form-field',
+    /** Material input */
+    input: 'input[matInput]',
+    /** Material tab group */
+    tabGroup: 'mat-tab-group',
+    /** Material tab label */
+    tabLabel: '.mat-mdc-tab',
+    /** Material paginator */
+    paginator: 'mat-paginator',
+    /** Material icon */
+    icon: 'mat-icon',
+    /** Material autocomplete panel */
+    autocompletePanel: '.mat-mdc-autocomplete-panel',
+    /** Material autocomplete option */
+    autocompleteOption: 'mat-option',
+};
+/**
+ * Helper functions for interacting with Angular Material components.
+ */
+class MaterialHelper {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    /** Get all visible table rows, optionally scoped to a parent locator */
+    tableRows(scope) {
+        const root = scope ?? this.page;
+        return root.locator(MaterialSelectors.row);
+    }
+    /** Get a single table row by index (0-based), optionally scoped to a parent locator */
+    tableRow(index, scope) {
+        return this.tableRows(scope).nth(index);
+    }
+    /** Click on a table row by index (0-based), optionally scoped to a parent locator */
+    async clickRow(index, scope) {
+        await this.tableRow(index, scope).click();
+    }
+    /** Get a tab by its label text */
+    tabByLabel(text) {
+        return this.page.locator(MaterialSelectors.tabLabel, { hasText: text });
+    }
+    /** Click a tab by its label text */
+    async clickTab(text) {
+        await this.tabByLabel(text).click();
+    }
+    /** Fill a mat-form-field input identified by its formControlName.
+     *  Supports both native inputs with formcontrolname and custom components (e.g. mat-autocomplete-field) wrapping an input. */
+    async fillFormControl(formControlName, value) {
+        // Try native input first, then fall back to custom component wrapper
+        const nativeInput = this.page.locator(`${MaterialSelectors.formField} input[formcontrolname="${formControlName}"]`);
+        const wrappedInput = this.page.locator(`[formcontrolname="${formControlName}"] input`);
+        const input = (await nativeInput.count()) > 0 ? nativeInput : wrappedInput;
+        // Click the parent mat-form-field to ensure focus reaches the input
+        const formField = input.locator('xpath=ancestor::mat-form-field');
+        if ((await formField.count()) > 0) {
+            await formField.first().click();
+        }
+        else {
+            await input.click({ force: true });
+        }
+        await input.pressSequentially(value, { delay: 50 });
+    }
+    /**
+     * Select an option from a mat-select dropdown by formControlName.
+     * Opens the dropdown, waits for options to render, clicks the matching option, then waits for the dropdown to close.
+     */
+    async selectMatSelectOption(formControlName, optionText) {
+        const select = this.page.locator(`mat-select[formcontrolname="${formControlName}"]`);
+        await select.click();
+        // Use role-based selector: mat-select renders options with role="option" in a listbox
+        const option = this.page.getByRole('option', { name: optionText });
+        await option.waitFor({ state: 'visible', timeout: 10_000 });
+        await option.click();
+        // Wait for the option to disappear (dropdown closed)
+        await option.waitFor({ state: 'hidden', timeout: 5_000 });
+    }
+    /** Select an autocomplete option by text after typing in a form control */
+    async selectAutocompleteOption(formControlName, searchText, optionText) {
+        await this.fillFormControl(formControlName, searchText);
+        const panel = this.page.locator(MaterialSelectors.autocompletePanel);
+        await panel.waitFor({ state: 'visible', timeout: 10_000 });
+        await panel.locator(MaterialSelectors.autocompleteOption, { hasText: optionText }).click();
+    }
+    /** Wait for table rows to be loaded (at least one row visible), optionally scoped to a parent locator */
+    async waitForTableRows(timeout = 15_000, scope) {
+        await this.tableRows(scope).first().waitFor({ state: 'visible', timeout });
+    }
+}
+
+/**
+ * Common UI helper functions to improve readability of e2e tests.
+ * This helper centralizes access to Ionic and Material specific helpers.
+ */
+class UiHelper {
+    page;
+    ionic;
+    mat;
+    constructor(page) {
+        this.page = page;
+        this.ionic = new IonicHelper(page);
+        this.mat = new MaterialHelper(page);
+    }
+    /**
+     * Click an element and wait for it to be ready.
+     * @param locator The locator to click.
+     * @param timeout The maximum time to wait.
+     */
+    async click(locator, timeout = 10_000) {
+        await locator.waitFor({ state: 'visible', timeout });
+        // force: true bypasses Ionic overlay elements (ion-col, ion-toolbar) that intercept pointer events
+        await locator.click({ force: true });
+    }
+    /**
+     * Fill an input and wait for it to be ready.
+     * @param locator The locator to fill.
+     * @param value The value to enter.
+     * @param timeout The maximum time to wait.
+     */
+    async fill(locator, value, timeout = 10_000) {
+        await locator.waitFor({ state: 'visible', timeout });
+        await locator.fill(value);
+    }
+    /**
+     * Wait for an element to be visible.
+     * @param locator The locator to wait for.
+     * @param timeout The maximum time to wait.
+     */
+    async waitForVisible(locator, timeout = 10_000) {
+        await locator.waitFor({ state: 'visible', timeout });
+    }
+    /**
+     * Wait for an element to be hidden.
+     * @param locator The locator to wait for.
+     * @param timeout The maximum time to wait.
+     */
+    async waitForHidden(locator, timeout = 15_000) {
+        await locator.waitFor({ state: 'hidden', timeout });
+    }
+    /* --- Unified Selectors --- */
+    /**
+     * Get a button by its text content.
+     * Supports both Ionic and Material buttons.
+     * @param text The text content to match.
+     * @param scope Optional locator to scope the search within.
+     */
+    button(text, scope) {
+        // Combine selectors for both Ionic and Material buttons
+        const selectors = [
+            IonicSelectors.button,
+            'button[mat-button]',
+            'button[mat-raised-button]',
+            'button[mat-flat-button]',
+            'button[mat-stroked-button]',
+            'button[mat-icon-button]',
+            'button[mat-fab]',
+            'button[mat-mini-fab]',
+        ].join(', ');
+        const root = scope ?? this.page;
+        return root.locator(selectors, { hasText: text });
+    }
+    /**
+     * Get an icon button by its icon name.
+     * Supports both Ionic and Material icon buttons.
+     * @param iconName The icon name (e.g. 'mail', 'search', 'ellipsis-horizontal').
+     * @param scope Optional locator to scope the search within.
+     */
+    iconButton(iconName, scope) {
+        const matIconSelector = `${MaterialSelectors.icon}:has-text("${iconName}")`;
+        const ionIconSelector = `ion-icon[name="${iconName}"]`;
+        const root = scope ?? this.page;
+        return root.locator(`button, ion-button`).filter({
+            has: this.page.locator(`${matIconSelector}, ${ionIconSelector}`),
+        });
+    }
+    /**
+     * Access to the underlying Playwright Page object.
+     */
+    get pageObj() {
+        return this.page;
+    }
+    /** Get a modal by its selector */
+    modal(selector) {
+        return this.ionic.modal(selector);
+    }
+    /** Get a tab by its label text */
+    tab(text) {
+        return this.mat.tabByLabel(text);
+    }
+    /* --- Specialized Helpers (delegated) --- */
+    /** Wait for the app to be ready */
+    async waitForAppReady(timeout = 15_000) {
+        await this.ionic.waitForAppReady(timeout);
+    }
+    /** Wait for loading spinners to disappear */
+    async waitForLoadingComplete(timeout = 15_000) {
+        await this.ionic.waitForLoadingComplete(timeout);
+    }
+    /** Wait for table rows to be loaded, optionally scoped to a parent locator */
+    async waitForTableRows(timeout = 15_000, scope) {
+        await this.mat.waitForTableRows(timeout, scope);
+    }
+    /** Get a single table row by index (0-based), optionally scoped to a parent locator */
+    tableRow(index, scope) {
+        return this.mat.tableRow(index, scope);
+    }
+    /** Click on a table row by index, optionally scoped to a parent locator */
+    async clickRow(index, scope) {
+        await this.click(this.tableRow(index, scope));
+    }
+    /** Fill a mat-form-field input identified by its formControlName */
+    async fillFormControl(formControlName, value) {
+        await this.mat.fillFormControl(formControlName, value);
+    }
+    /** Select an autocomplete option */
+    async selectAutocompleteOption(formControlName, searchText, optionText) {
+        await this.mat.selectAutocompleteOption(formControlName, searchText, optionText);
+    }
+    /**
+     * Select an option from a mat-select dropdown.
+     * Opens the dropdown, waits for options, clicks the matching one, then waits for the dropdown to close.
+     */
+    async selectOption(formControlName, optionText) {
+        await this.mat.selectMatSelectOption(formControlName, optionText);
+    }
+}
+
+/**
+ * Helper for authentication in e2e tests.
+ */
+class AuthHelper {
+    page;
+    ui;
+    constructor(page, ui) {
+        this.page = page;
+        this.ui = ui ?? new UiHelper(page);
+    }
+    /** Login with given test credentials */
+    async login(username, password) {
+        const ui = this.ui;
+        await this.page.goto('/');
+        // Wait for the app to fully load (backend connection can take time)
+        await ui.waitForAppReady(30_000);
+        await ui.waitForLoadingComplete(30_000);
+        // Click the login button on the home page
+        const loginButton = ui.button(/Se connecter|Log In/).first();
+        await ui.click(loginButton, 30_000);
+        // Wait for the auth modal to appear
+        const modal = ui.modal('app-auth-form');
+        await ui.waitForVisible(modal);
+        // Fill credentials (may or may not be pre-filled depending on the environment)
+        const usernameInput = modal.locator('input[formcontrolname="username"]');
+        await usernameInput.click({ force: true });
+        await usernameInput.fill(username);
+        const passwordInput = modal.locator('input[formcontrolname="password"]');
+        await passwordInput.click({ force: true });
+        await passwordInput.fill(password);
+        // Click the submit button in the modal footer
+        const ionModal = ui.pageObj.locator('ion-modal:has(app-auth-form)');
+        const submitButton = ionModal.locator('ion-footer ion-button[color="tertiary"]');
+        await submitButton.waitFor({ state: 'visible', timeout: 10_000 });
+        // Wait for the button to be enabled (form valid)
+        await ui.pageObj.waitForFunction((btn) => !btn.hasAttribute('disabled'), await submitButton.elementHandle(), { timeout: 5_000 });
+        await submitButton.click();
+        // Wait for the modal to close and verify the user is logged in
+        await ui.waitForHidden(modal, 30_000);
+        // After login, the login button should no longer be visible (replaced by user menu)
+        await loginButton.waitFor({ state: 'hidden', timeout: 10_000 });
+    }
+    /** Wait until the user is logged in and return the email shown in the side menu */
+    async waitForLoggedIn() {
+        const emailEl = this.page.locator('ion-menu h4').first();
+        await emailEl.waitFor({ state: 'visible', timeout: 30_000 });
+        return emailEl.textContent();
+    }
+    /** Setup startup data with provided credentials or environment variables */
+    async loginByEnv(opts) {
+        const username = opts?.username ?? process.env.E2E_USERNAME;
+        const password = opts?.password ?? process.env.E2E_PASSWORD;
+        const offline = opts?.offline ?? process.env.E2E_OFFLINE === 'true';
+        const peerUrl = opts?.peerUrl ?? process.env.E2E_PEER_URL;
+        if (!username && !password && !peerUrl)
+            return;
+        await this.page.addInitScript(({ key, username, password, offline, peerUrl }) => {
+            window[key] = { username, password, offline, peerUrl };
+        }, { key: STARTUP_DATA_STORAGE_KEY, username, password, offline, peerUrl });
+    }
+}
+
+// GPL v3 License
+/**
+ * Search environments based on provided criteria.
+ *
+ * Use when you need to run tests with one or more environments.
+ * Test can use `testWithEnv` to run tests with a specific environment.
+ * Example :
+ *
+ * ```
+ * test.describe('Sample test with environment', () => {
+ *    withEnvs({
+ *      peerTags: ['local'],
+ *      userTags: ['admin'],
+ *    }).forEach((env) => {
+ *      testWithEnv(env)(`Some test with environment ${env.id}`, async ({ page }) => {
+ *        // Test implementation
+ *      });
+ *    });
+ * });
+ * ```
+ *
+ * Environments are loaded from a JSON config file located at one of four paths :
+ * - `LOGIN_ENVS_PATH` environment variable
+ * - `.environments.json` in the current directory (e.g. `.environments.json`)
+ * - `.environments.json` in the `.local` directory (e.g. `.local/environments.json`)
+ * - `.environments.json` in the `e2e` directory (e.g. `e2e/.environments.json`)
+ *
+ * Example of JSON :
+ *
+ * ```
+ * {
+ *   "peers": [
+ *     {
+ *       "id": "local",
+ *       "tags": ["local"],
+ *       "url": "http://localhost:8080",
+ *       "users": [
+ *         {
+ *           "tags": ["admin"],
+ *           "username": "admin@sumaris.net",
+ *           "password": "admin"
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * @see testWithEnv
+ * @param filter Search criteria.
+ */
+function withEnvs(filter) {
+    const startupEnvs = [];
+    // Search startup env config file
+    const candidates = [
+        process.env.LOGIN_ENVS_PATH,
+        path.resolve(process.cwd(), '.environments.json'),
+        path.resolve(process.cwd(), '.local/environments.json'),
+        path.resolve(process.cwd(), 'e2e/.environments.json'),
+    ].filter(Boolean);
+    const environmentsFile = candidates.find((p) => fs.existsSync(p));
+    if (!environmentsFile) {
+        throw new Error(`Startup envs config file not found.\nTried: ${candidates.join('\n')}`);
+    }
+    // Load startup config file
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(environmentsFile, 'utf8'));
+    }
+    catch (error) {
+        console.error('Error parsing startup envs config file:', error);
+        throw error;
+    }
+    finally {
+        fs.closeSync(fs.openSync(environmentsFile, 'r'));
+    }
+    // Filter startup envs based on criteria
+    for (const peerConfig of config.peers) {
+        const matchPeerId = filter.peerId && peerConfig.id === filter.peerId;
+        const matchPeerTag = filter.peerTags && peerConfig.tags.some((tag) => filter.peerTags?.includes(tag));
+        if (!matchPeerId && !matchPeerTag)
+            continue;
+        for (const userConfig of peerConfig.users) {
+            const matchUserTag = filter.userTags && userConfig.tags.some((tag) => filter.userTags?.includes(tag));
+            if (!matchUserTag)
+                continue;
+            startupEnvs.push({
+                id: peerConfig.id,
+                peerUrl: peerConfig.url,
+                username: userConfig.username,
+                password: userConfig.password,
+            });
+        }
+    }
+    return startupEnvs;
+}
+/**
+ * Currying function that returns a test function that can be used to run tests with a specific environment.
+ *
+ * ```
+ * testWithEnv(env)(`Some test with environment ${env.id}`, async ({ page }) => {
+ *   // Test implementation
+ * })
+ * ```
+ *
+ * @see withEnvs
+ * @param env Environment to use for the test.
+ */
+function testWithEnv(env) {
+    return (title, testFn) => {
+        test(title, async ({ page, context: playwrightContext, browser, request }) => {
+            const auth = new AuthHelper(page);
+            await auth.loginByEnv(env);
+            await testFn({ page, context: playwrightContext, browser, request });
+        });
+    };
+}
+
+// constants
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthHelper, IonicHelper, IonicSelectors, MaterialHelper, MaterialSelectors, STARTUP_DATA_STORAGE_KEY, UiHelper, testWithEnv, withEnvs };
+//# sourceMappingURL=sumaris-net-ngx-components-testing.mjs.map