@jahia/cypress 7.4.0 → 8.1.0

package/dist/support/jfaker.js

@@ -0,0 +1,241 @@
+"use strict";
+/* eslint-disable no-else-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * jfaker - A flexible data generator for Cypress tests, supporting both faker.js generated data and custom injection payloads.
+ *
+ * This module provides a unified interface to generate either faker data or custom injection payloads based on the method called and global settings.
+ * It uses a dynamic Proxy to handle method calls and determine whether to generate faker data or injection data.
+ *
+ * IMPORTANT:
+ * When using the generated strings from jfaker in Cypress commands like `.type()`, make sure to:
+ * use `parseSpecialCharSequences: false`, e.g.: `<input>.type(text, {parseSpecialCharSequences: false})`
+ * to prevent Cypress from interpreting special characters in the generated strings (e.g., {, }, [, ], etc.) as commands,
+ * which is especially important for injection payloads that may contain such characters.
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jfaker = void 0;
+var faker_1 = require("@faker-js/faker");
+// Import injection data from corresponding files in injections-ts directory
+var xss_data_1 = require("../injections/xss-data");
+var sql_data_1 = require("../injections/sql-data");
+var bash_data_1 = require("../injections/bash-data");
+var chars_data_1 = require("../injections/chars-data");
+var htmlentities_data_1 = require("../injections/htmlentities-data");
+var numbers_data_1 = require("../injections/numbers-data");
+var injectionData = {
+    xss: xss_data_1.xssData,
+    sql: sql_data_1.sqlData,
+    bash: bash_data_1.bashData,
+    chars: chars_data_1.charsData,
+    htmlentities: htmlentities_data_1.htmlentitiesData,
+    numbers: numbers_data_1.numbersData
+};
+// Environment variable key for storing injection type in Cypress env
+// Can be set either using corresponding FakeData method or as an env var from CI/CD pipeline
+var ENV_INJECTIONS_TYPE = 'JAHIA_CYPRESS_INJECTION_TYPE';
+// Default range for random length of injection payloads; used when length is undefined
+// Random items within the range will be picked and joined into a single string
+var injectionsDefaultLength = { min: 2, max: 5 };
+/**
+ * Store FakeData type in Cypress env for persistence across specs
+ * @param {string} type FakeData type: 'faker' | 'xss' | 'sql' | 'bash' | 'chars' | 'htmlentities' | 'numbers'
+ * @returns void
+ */
+function setDataType(type) {
+    Cypress.env(ENV_INJECTIONS_TYPE, type);
+}
+/**
+ * Retrieve FakeData type from Cypress env (defaults to 'faker' if not set)
+ * @returns {string} Type of FakeData to use
+ */
+function getDataType() {
+    return Cypress.env(ENV_INJECTIONS_TYPE) || 'faker';
+}
+/**
+ * Generate injection data based on the specified type and length
+ * @param {string} type Injection type to generate (xss, sql, bash, chars, htmlentities, numbers)
+ * @param {number} length Length of the generated injection (optional)
+ * @returns {string} Generated injection string
+ */
+function generateInjection(type, length) {
+    var result = [];
+    // Type is specified and exists in injectionData, use it to generate data
+    var data = injectionData[type];
+    if (!data || data.length === 0) {
+        throw new Error("[jFaker EXCEPTION] No injection data found for type: ".concat(type, "."));
+    }
+    if (length === -1) {
+        // If length is -1, use all available items from the data array
+        result = data;
+    }
+    else if (length && length > 0) {
+        // If length is specified and greater than 0, pick random items until the combined length meets the requirement
+        while (result.join('').length < length) {
+            var randomIndex = Math.floor(Math.random() * data.length);
+            result.push(data[randomIndex]);
+        }
+        // Trim the combined string to the specified length
+        var combined = result.join('');
+        result = [combined.substring(0, length)];
+    }
+    else {
+        // If length is not specified, pick a random number of items within the default range
+        var itemsCount = Math.floor(Math.random() * injectionsDefaultLength.max) + injectionsDefaultLength.min;
+        for (var i = 0; i < itemsCount; i++) {
+            var randomIndex = Math.floor(Math.random() * data.length);
+            result.push(data[randomIndex]);
+        }
+    }
+    return result.join('');
+}
+/**
+ * Generate faker data based on the specified entity and options
+ * @param {string} entity Faker entity to generate (e.g., "person.firstName")
+ * @param {Record<string, unknown> | string | number | boolean | undefined} options Options to pass to the faker method (optional)
+ * @returns {string} Generated faker string
+ */
+function generateFake(entity, options) {
+    var generator;
+    var result = [];
+    var parts = entity.split('.');
+    var fakerMethod = faker_1.faker;
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        if (fakerMethod && typeof fakerMethod[part] !== 'undefined') {
+            fakerMethod = fakerMethod[part];
+        }
+        else {
+            throw new Error("[jFaker EXCEPTION] Invalid faker method: ".concat(entity));
+        }
+    }
+    if (typeof fakerMethod === 'function') {
+        generator = (options && Object.keys(options).length > 0) ? function () { return fakerMethod(options); } : function () { return fakerMethod(); };
+    }
+    else {
+        throw new Error("[jFaker EXCEPTION] ".concat(entity, " is not a function"));
+    }
+    result.push(generator());
+    return result.join('');
+}
+/**
+ * Escape string to prevent issues when used in contexts like HTML or JavaScript
+ * @param str
+ */
+function escape(str) {
+    return JSON.stringify(str).slice(1, -1);
+}
+/**
+ * Simple DeepApi class to create a dynamic nested Proxy for generating fake data using faker or injection data based on method calls
+ */
+var DeepApi = /** @class */ (function () {
+    function DeepApi(handler) {
+        this.handler = handler;
+        return this.createProxy([]);
+    }
+    DeepApi.prototype.createProxy = function (path) {
+        var _this = this;
+        return new Proxy(
+        // The target is a function, so the proxy itself is callable
+        function () { }, {
+            // Handle property access - go deeper
+            get: function (target, prop) {
+                return _this.createProxy(__spreadArray(__spreadArray([], path, true), [String(prop)], false));
+            },
+            // Handle function call - execute handler
+            apply: function (target, thisArg, args) {
+                return _this.handler(path.join('.'), args);
+            }
+        });
+    };
+    return DeepApi;
+}());
+/**
+ * Interface to Fake Data generator (using DeepApi proxy to handle dynamic method calls)
+ * @param {Record<string, unknown>} options Options for data generation (length for injections, faker options, safe flag), \
+ *                                          e.g.: `{length: 100}` for injections to specify desired length of the generated string, \
+ *                                          or `{provider: 'example.com'}` for faker to pass options to the faker method. \
+ *                                          For faker data generation, an additional option `safe` can be set to `true` \
+ *                                          to force faker generation regardless of global type settings \
+ *                                          (useful for specific cases where faker data is needed even when global type is set to injection).
+ * @remarks
+ * Available injection methods:
+ * - `.xss()` - Generate XSS injection payloads
+ * - `.sql()` - Generate SQL injection payloads
+ * - `.bash()` - Generate Bash injection payloads
+ * - `.chars()` - Generate random special characters
+ * - `.htmlentities()` - Generate HTML entities
+ * - `.numbers()` - Generate random numbers entities and edge cases
+ * - or any faker.js method can also be called (e.g., `person.firstName()`, `internet.email()`)
+ *
+ * @returns {string} Generated data string based on the method called and options provided
+ *
+ * @see https://fakerjs.dev/api/ for available faker methods and options
+ * @example
+ * ```typescript
+ *
+ * // Generate faker data with entity.
+ * const name = jfaker.person.firstName();
+ *
+ * // Entity will always be generated using faker (safe: true)
+ * const name = jfaker.person.firstName({safe: true});
+ *
+ * // Generate faker data with options.
+ * const email = jfaker.internet.email({provider: 'example.com'});
+ *
+ * // Generate injection payloads (random between min and max items joined into a single string)..
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss();
+ *
+ * // Generate injection payloads with specific length.
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss({length: 100});
+ *
+ * // Use all SQL injections.
+ * // Entity will always be generated using 'sql'.
+ * const allSql = jfaker.sql({length: -1});
+ * ```
+ */
+var jfaker = new DeepApi(function (path, args) {
+    var _a, _b, _c, _d;
+    // Handle non-faker methods first (escape, setFakeDataType, getFakeDataType)
+    switch (path) {
+        case 'escape':
+            return escape(args[0]);
+        case 'setDataType':
+            return setDataType(args[0]);
+        case 'getDataType':
+            return getDataType();
+        case Object.prototype.hasOwnProperty.call(injectionData, path) ? path : 'default':
+            // If the path corresponds to a valid injection type, generate data using that type,
+            // or fallback to default case which treats the path as a faker entity.
+            // Keep (safe === true) logic in "default" case for a readability.
+            return generateInjection(path, (_a = args[0]) === null || _a === void 0 ? void 0 : _a.length);
+        default: {
+            // For faker data generation, check if the generation should be persistent based on global settings and options passed.
+            var safe = ((_b = args[0]) === null || _b === void 0 ? void 0 : _b.safe) === true;
+            // Delete the 'safe' property from options to avoid passing it to faker methods
+            (_c = args[0]) === null || _c === void 0 ? true : delete _c.safe;
+            // Here path represents a faker entity.
+            // Check desired data type and 'safe' option to determine whether to generate faker data or injection data.
+            // If global type is set to injection (to override faker data) but safe is explicitly set to true in options -
+            // generate faker data for this specific call regardless of global settings.
+            if (getDataType() === 'faker' || safe) {
+                return generateFake(path, args[0]);
+            }
+            else {
+                return generateInjection(getDataType(), (_d = args[0]) === null || _d === void 0 ? void 0 : _d.length);
+            }
+        }
+    }
+});
+exports.jfaker = jfaker;

package/dist/support/jsErrorsLogger.js

@@ -1,12 +1,16 @@
 "use strict";
 /* eslint-disable brace-style */
 /* eslint-disable max-statements-per-line */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.jsErrorsLogger = void 0;
 /**
  * Module for monitoring and reporting JavaScript errors and warnings in Cypress tests.
@@ -152,9 +156,9 @@ function collectIssues(win) {
         .then(function () {
         // Update the Cypress environment variable with the collected issues
         if (consoleIssues.length > 0) {
-            setCollectedIssues(__spreadArray(__spreadArray([], getCollectedIssues()), [
+            setCollectedIssues(__spreadArray(__spreadArray([], getCollectedIssues(), true), [
                 { url: win.location.href, test: Cypress.currentTest.title, errors: consoleIssues }
-            ]));
+            ], false));
         }
     });
 }
@@ -174,12 +178,12 @@ function analyzeIssues() {
             var errorMessage = Object.entries(groupedByTest).map(function (_a) {
                 var test = _a[0], items = _a[1];
                 var urlsAndErrors = items.map(function (item) {
-                    return "URL: " + item.url + "\nISSUES:\n" + item.errors.map(function (e) { return "- " + (e.type === 'warn' ? getEmoji('warn') : getEmoji('error')) + " " + e.msg; }).join('\n');
+                    return "URL: ".concat(item.url, "\nISSUES:\n").concat(item.errors.map(function (e) { return "- ".concat(e.type === 'warn' ? getEmoji('warn') : getEmoji('error'), " ").concat(e.msg); }).join('\n'));
                 }).join('\n\n');
                 // Return the formatted message for the test;
                 // Intentionally use fixed-width (50 chars) separators for better readability,
                 // when the message might be wrapped
-                return getEmoji('error') + "\uFE0F TEST: " + test.trim() + " " + getEmoji('error') + "\uFE0F\n" + '-'.repeat(50) + "\n" + urlsAndErrors + "\n" + '='.repeat(50);
+                return "".concat(getEmoji('error'), "\uFE0F TEST: ").concat(test.trim(), " ").concat(getEmoji('error'), "\uFE0F\n").concat('-'.repeat(50), "\n").concat(urlsAndErrors, "\n").concat('='.repeat(50));
             }).join('\n\n');
             // Reset the collector for the next test run
             setCollectedIssues([]);

package/dist/support/login.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="cypress" />
 declare global {
     namespace Cypress {
         interface Chainable<Subject> {

package/dist/support/login.js

@@ -1,6 +1,6 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.loginAndStoreSession = exports.login = void 0;
 /// <reference types="cypress" />
 // Disable linter to keep as this for backward compatibility
@@ -11,7 +11,7 @@ var login = function (username, password, config) {
     if (password === void 0) { password = Cypress.env('SUPER_USER_PASSWORD'); }
     Cypress.log({
         name: 'login',
-        message: "Login with " + username,
+        message: "Login with ".concat(username),
         consoleProps: function () {
             return {
                 User: username

package/dist/support/logout.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="cypress" />
 declare global {
     namespace Cypress {
         interface Chainable<Subject> {

package/dist/support/logout.js

@@ -1,6 +1,6 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.logout = void 0;
 /// <reference types="cypress" />
 var logout = function () {

package/dist/support/modSince.d.ts

@@ -0,0 +1,52 @@
+/** Cypress environment variable key used to store the current Jahia version. */
+export declare const JAHIA_VERSION_ENV_VAR = "CYPRESS_JAHIA_VERSION";
+declare global {
+    namespace Mocha {
+        interface TestFunction {
+            since(requiredVersion: string, title: string, fn?: Func): Test;
+            since(requiredVersion: string, title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test;
+        }
+        interface ExclusiveTestFunction {
+            since(requiredVersion: string, title: string, fn?: Func): Test;
+            since(requiredVersion: string, title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test;
+        }
+        interface PendingTestFunction {
+            since(requiredVersion: string, title: string, fn?: Func): Test;
+            since(requiredVersion: string, title: string, config: Cypress.TestConfigOverrides, fn?: Func): Test;
+        }
+        interface SuiteFunction {
+            since(requiredVersion: string, title: string, fn: (this: Suite) => void): Suite;
+        }
+        interface ExclusiveSuiteFunction {
+            since(requiredVersion: string, title: string, fn: (this: Suite) => void): Suite;
+        }
+        interface PendingSuiteFunction {
+            since(requiredVersion: string, title: string, fn: (this: Suite) => void): Suite;
+        }
+    }
+}
+/**
+ * Fetches the Jahia version from the GraphQL API, strips the `-SNAPSHOT` suffix,
+ * and caches the result in `Cypress.env(JAHIA_VERSION_ENV_VAR)`.
+ */
+export declare const initializeVersionSupport: () => Cypress.Chainable<any>;
+/**
+ * Attaches `.since()` to `it`, `it.only`, `it.skip`, `describe`, `describe.only`,
+ * and `describe.skip`. Safe to call multiple times — subsequent calls are no-ops.
+ */
+export declare const registerVersionSupport: () => void;
+/**
+ * Enables version-gated testing for the Cypress suite.
+ * Registers `it.since`, `describe.since` (and their `.only`/`.skip` variants),
+ * then fetches the running Jahia version in a root `before()` hook.
+ *
+ * @example
+ * it.since('8.2.0', 'works on 8.2+', () => { ... });
+ * describe.since('8.2.0', 'suite for 8.2+', () => { ... });
+ */
+declare function enable(): void;
+/** Public API for Jahia version-gated testing. */
+export declare const modSince: {
+    enable: typeof enable;
+};
+export {};

package/dist/support/modSince.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modSince = exports.registerVersionSupport = exports.initializeVersionSupport = exports.JAHIA_VERSION_ENV_VAR = void 0;
+var compare_versions_1 = require("compare-versions");
+// Intentionally keep explicit path to avoid edge case errors in runtime
+var JahiaPlatformHelper_1 = require("../utils/JahiaPlatformHelper");
+/** Cypress environment variable key used to store the current Jahia version. */
+exports.JAHIA_VERSION_ENV_VAR = 'CYPRESS_JAHIA_VERSION';
+// ─── Internal helpers ────────────────────────────────────────────────────────
+/**
+ * Returns `true` when `current` satisfies `>= required`.
+ * Treats missing, empty, or unparseable versions as unsupported.
+ * @param current - The running Jahia version read from `Cypress.env`.
+ * @param required - Minimum version the test or suite needs.
+ */
+var isSupported = function (current, required) {
+    if (!(current === null || current === void 0 ? void 0 : current.trim())) {
+        return false;
+    }
+    try {
+        return (0, compare_versions_1.compare)(String(current), required, '>=');
+    }
+    catch (_a) {
+        return false;
+    }
+};
+/**
+ * Validates `since(...)` arguments and throws a descriptive error on misuse.
+ * Detects the common mistake of swapping `requiredVersion` and `title`.
+ * @param version - Version string passed as the first argument.
+ * @param title - Title string passed as the second argument.
+ * @param scope - Label used in the error message (e.g. `"it.since"`).
+ */
+var assertArgs = function (version, title, scope) {
+    if (!(0, compare_versions_1.validate)(version)) {
+        var hint = (0, compare_versions_1.validate)(title) ? ' (arguments appear swapped)' : '';
+        throw new Error("[".concat(scope, "] Invalid version: \"").concat(version, "\"").concat(hint, "."));
+    }
+};
+/**
+ * Builds a human-readable message explaining why a test or suite was skipped.
+ * @param scope - Label for the helper (e.g. `"it.since"` or `"describe.since"`).
+ * @param title - Original test or suite title.
+ * @param required - Minimum version the test or suite needs.
+ * @param current - The running Jahia version; `undefined` when not yet fetched.
+ */
+var skipReason = function (scope, title, required, current) {
+    return current ?
+        "[".concat(scope, "] Skipping \"").concat(title, "\" \u2014 ").concat(exports.JAHIA_VERSION_ENV_VAR, "=\"").concat(current, "\" < required ").concat(required, ".") :
+        "[".concat(scope, "] Skipping \"").concat(title, "\" \u2014 ").concat(exports.JAHIA_VERSION_ENV_VAR, " is not set. Required: ").concat(required, ".");
+};
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Fetches the Jahia version from the GraphQL API, strips the `-SNAPSHOT` suffix,
+ * and caches the result in `Cypress.env(JAHIA_VERSION_ENV_VAR)`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var initializeVersionSupport = function () {
+    return (0, JahiaPlatformHelper_1.getJahiaVersion)().then(function (jahiaVersion) {
+        var version = jahiaVersion.release.replace('-SNAPSHOT', '');
+        Cypress.env(exports.JAHIA_VERSION_ENV_VAR, version);
+        return version;
+    });
+};
+exports.initializeVersionSupport = initializeVersionSupport;
+/**
+ * Attaches `.since()` to `it`, `it.only`, `it.skip`, `describe`, `describe.only`,
+ * and `describe.skip`. Safe to call multiple times — subsequent calls are no-ops.
+ */
+var registerVersionSupport = function () {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var mochaIt = globalThis.it;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var mochaDescribe = globalThis.describe;
+    if (!mochaIt) {
+        throw new Error('Unable to register version support because Mocha `it` is not available.');
+    }
+    if (!mochaDescribe) {
+        throw new Error('Unable to register version support because Mocha `describe` is not available.');
+    }
+    var _loop_1 = function (target) {
+        if (typeof target.since === 'function') {
+            return "continue";
+        }
+        var isSkip = target === mochaIt.skip;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        target.since = function (version, title, configOrFn, maybeFn) {
+            assertArgs(version, title, 'it.since');
+            if (isSkip) {
+                // It.skip.since: always skip unconditionally, preserve the title
+                return typeof configOrFn === 'function' || configOrFn === undefined ?
+                    target(title, configOrFn) :
+                    target(title, configOrFn, maybeFn);
+            }
+            var userFn = typeof configOrFn === 'function' ? configOrFn : maybeFn;
+            var wrappedFn = function () {
+                var current = Cypress.env(exports.JAHIA_VERSION_ENV_VAR);
+                if (!isSupported(current, version)) {
+                    console.warn(skipReason('it.since', title, version, current));
+                    this.skip();
+                }
+                else if (typeof userFn === 'function') {
+                    return userFn.call(this);
+                }
+            };
+            return typeof configOrFn === 'object' && configOrFn !== null ?
+                target(title, configOrFn, wrappedFn) :
+                target(title, wrappedFn);
+        };
+    };
+    // Attach .since() to it / it.only / it.skip
+    for (var _i = 0, _a = [mochaIt, mochaIt.only, mochaIt.skip]; _i < _a.length; _i++) {
+        var target = _a[_i];
+        _loop_1(target);
+    }
+    var _loop_2 = function (target) {
+        if (typeof target.since === 'function') {
+            return "continue";
+        }
+        var isSkip = target === mochaDescribe.skip;
+        target.since = function (version, title, fn) {
+            assertArgs(version, title, 'describe.since');
+            if (isSkip) {
+                // Describe.skip.since: always skip unconditionally, preserve the title
+                return target(title, fn);
+            }
+            return target(title, function () {
+                // Suite-level runtime check runs after the global before() has fetched the version
+                before(function () {
+                    var current = Cypress.env(exports.JAHIA_VERSION_ENV_VAR);
+                    if (!isSupported(current, version)) {
+                        console.warn(skipReason('describe.since', title, version, current));
+                        this.skip();
+                    }
+                });
+                fn.call(this);
+            });
+        };
+    };
+    // Attach .since() to describe / describe.only / describe.skip
+    for (var _b = 0, _c = [mochaDescribe, mochaDescribe.only, mochaDescribe.skip]; _b < _c.length; _b++) {
+        var target = _c[_b];
+        _loop_2(target);
+    }
+    // Compatibility shim: redirect accidental it.skip(version, title, fn) → it.skip.since(...)
+    var origItSkip = mochaIt.skip;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mochaIt.skip = Object.assign(function (title, configOrTitle, maybeFn) {
+        if ((0, compare_versions_1.validate)(title) && typeof configOrTitle === 'string' && typeof maybeFn === 'function') {
+            return origItSkip.since(title, configOrTitle, maybeFn);
+        }
+        return typeof configOrTitle === 'function' || configOrTitle === undefined ?
+            origItSkip(title, configOrTitle) :
+            origItSkip(title, configOrTitle, maybeFn);
+    }, { since: origItSkip.since });
+    var origDescribeSkip = mochaDescribe.skip;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mochaDescribe.skip = Object.assign(function (title, fnOrTitle, maybeFn) {
+        if ((0, compare_versions_1.validate)(title) && typeof fnOrTitle === 'string' && typeof maybeFn === 'function') {
+            return origDescribeSkip.since(title, fnOrTitle, maybeFn);
+        }
+        return origDescribeSkip(title, fnOrTitle);
+    }, { since: origDescribeSkip.since });
+};
+exports.registerVersionSupport = registerVersionSupport;
+/**
+ * Enables version-gated testing for the Cypress suite.
+ * Registers `it.since`, `describe.since` (and their `.only`/`.skip` variants),
+ * then fetches the running Jahia version in a root `before()` hook.
+ *
+ * @example
+ * it.since('8.2.0', 'works on 8.2+', () => { ... });
+ * describe.since('8.2.0', 'suite for 8.2+', () => { ... });
+ */
+function enable() {
+    (0, exports.registerVersionSupport)();
+    before(function () { return (0, exports.initializeVersionSupport)(); });
+}
+/** Public API for Jahia version-gated testing. */
+exports.modSince = { enable: enable };

package/dist/support/provisioning/executeGroovy.d.ts

@@ -7,7 +7,7 @@ declare global {
         }
     }
 }
-declare type JahiaServer = {
+type JahiaServer = {
     url: string;
     username: string;
     password: string;

package/dist/support/provisioning/executeGroovy.js

@@ -1,6 +1,6 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeGroovy = void 0;
 /// <reference types="cypress" />
 var serverDefaults = {
@@ -10,6 +10,36 @@ var serverDefaults = {
 };
 var executeGroovy = function (scriptFile, replacements, jahiaServer) {
     if (jahiaServer === void 0) { jahiaServer = serverDefaults; }
+    var result;
+    var duration;
+    var scriptContent;
+    var startTime = Date.now();
+    var replacementsLabel = replacements && Object.keys(replacements).length > 0 ?
+        " \u2014 ".concat(JSON.stringify(replacements)) :
+        '';
+    var logger = Cypress.log({
+        autoEnd: false,
+        name: 'executeGroovy',
+        displayName: 'groovy',
+        message: "".concat(scriptFile).concat(replacementsLabel),
+        consoleProps: function () { return ({
+            Script: scriptFile,
+            'Script Content': scriptContent !== null && scriptContent !== void 0 ? scriptContent : '(loading...)',
+            Replacements: replacements !== null && replacements !== void 0 ? replacements : {},
+            Server: jahiaServer.url,
+            Duration: duration === undefined ? 'pending' : "".concat(duration, "ms"),
+            Result: result
+        }); }
+    });
+    cy.fixture(scriptFile, 'utf-8').then(function (content) {
+        var processed = content;
+        if (replacements) {
+            Object.keys(replacements).forEach(function (k) {
+                processed = processed.replaceAll(k, replacements[k]);
+            });
+        }
+        scriptContent = processed;
+    });
     cy.runProvisioningScript({
         script: {
             fileContent: '- executeScript: "' + scriptFile + '"',
@@ -21,7 +51,16 @@ var executeGroovy = function (scriptFile, replacements, jahiaServer) {
                 type: 'text/plain',
                 encoding: 'utf-8'
             }],
-        jahiaServer: jahiaServer
-    }).then(function (r) { return r[0]; });
+        jahiaServer: jahiaServer,
+        options: { log: false }
+    }).then(function (r) {
+        result = r === null || r === void 0 ? void 0 : r[0];
+        duration = Date.now() - startTime;
+        var hasFailed = typeof result === 'string' && result.includes('.failed');
+        var prefix = hasFailed ? '❌ ' : '✅ ';
+        logger.set('message', "".concat(prefix).concat(scriptFile).concat(replacementsLabel));
+        logger === null || logger === void 0 ? void 0 : logger.end();
+        return result;
+    });
 };
 exports.executeGroovy = executeGroovy;

package/dist/support/provisioning/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -9,7 +13,7 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./executeGroovy"), exports);
 __exportStar(require("./runProvisioningScript"), exports);
 __exportStar(require("./installModule"), exports);

package/dist/support/provisioning/installConfig.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="cypress" />
 declare global {
     namespace Cypress {
         interface Chainable<Subject> {