@baloise/ds-testing 0.0.5-nightly.20240301

package/helpers.esm.js

@@ -0,0 +1,359 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function __generator(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function sent() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g;
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+typeof SuppressedError === "function" ? SuppressedError : function _SuppressedError(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var deepReady = /*#__PURE__*/ _async_to_generator(function(el, full) {
+    var element, stencilEl;
+    return __generator(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                if (full === void 0) full = false;
+                element = el;
+                if (!element) return [
+                    3,
+                    4
+                ];
+                if (!(element.componentOnReady !== null && element.componentOnReady !== undefined)) return [
+                    3,
+                    2
+                ];
+                return [
+                    4,
+                    element.componentOnReady()
+                ];
+            case 1:
+                stencilEl = _state.sent();
+                if (!full && stencilEl !== null && stencilEl !== undefined) {
+                    return [
+                        2
+                    ];
+                }
+                _state.label = 2;
+            case 2:
+                return [
+                    4,
+                    Promise.all(Array.from(element.children).map(function(child) {
+                        return deepReady(child, full);
+                    }))
+                ];
+            case 3:
+                _state.sent();
+                _state.label = 4;
+            case 4:
+                return [
+                    2
+                ];
+        }
+    });
+});
+var rIC = function(callback, timeout) {
+    if (timeout === void 0) timeout = 5000;
+    if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+        window.requestIdleCallback(callback, {
+            timeout: timeout
+        });
+    } else {
+        setTimeout(callback, 32);
+    }
+};
+var waitAfterFramePaint = function() {
+    return new Promise(function(resolve) {
+        return raf(function() {
+            return runHighPrioritizedTask(resolve);
+        });
+    });
+};
+var waitAfterIdleCallback = function(timeout) {
+    return new Promise(function(resolve) {
+        return rIC(function() {
+            return runHighPrioritizedTask(resolve);
+        }, timeout);
+    });
+};
+var raf = function(h) {
+    if (typeof __zone_symbol__requestAnimationFrame === "function") {
+        return __zone_symbol__requestAnimationFrame(h);
+    }
+    if (typeof requestAnimationFrame === "function") {
+        return requestAnimationFrame(h);
+    }
+    return setTimeout(h);
+};
+var runHighPrioritizedTask = function(callback) {
+    if (typeof window !== "undefined" && "MessageChannel" in window) {
+        var messageChannel = new window.MessageChannel();
+        messageChannel.port1.onmessage = callback;
+        messageChannel.port2.postMessage(undefined);
+    } else {
+        setTimeout(callback, 32);
+    }
+};
+var isElement = function(el, name) {
+    return typeof el === "object" && el.length > 0 && el[0].nodeName === name;
+};
+var hasClass = function(el, name) {
+    return typeof el === "object" && el.length > 0 && el.hasClass(name);
+};
+var hasTestId = function(el, testId) {
+    if (typeof el === "object" && el.length > 0) {
+        var dataTestId = el.data("testid");
+        return dataTestId === testId;
+    }
+    return false;
+};
+var isLabel = function(el) {
+    return isElement(el, "LABEL");
+};
+var isAccordion = function(el) {
+    return isElement(el, "BAL-ACCORDION");
+};
+var isButton = function(el) {
+    return isElement(el, "BAL-BUTTON");
+};
+var isCheckbox = function(el) {
+    return isElement(el, "BAL-CHECKBOX");
+};
+var isDatepicker = function(el) {
+    return isElement(el, "BAL-DATEPICKER");
+};
+var isNumberInput = function(el) {
+    return isElement(el, "BAL-NUMBER-INPUT");
+};
+var isRadio = function(el) {
+    return isElement(el, "BAL-RADIO");
+};
+var isSelect = function(el) {
+    return isElement(el, "BAL-SELECT");
+};
+var isTag = function(el) {
+    return isElement(el, "BAL-TAG");
+};
+var isTabs = function(el) {
+    return isElement(el, "BAL-TABS");
+};
+var isSteps = function(el) {
+    return isElement(el, "BAL-STEPS");
+};
+var isSlider = function(el) {
+    return isElement(el, "BAL-INPUT-SLIDER");
+};
+var isHint = function(el) {
+    return isElement(el, "BAL-HINT");
+};
+var isTextarea = function(el) {
+    return isElement(el, "BAL-TEXTAREA");
+};
+var isInputStepper = function(el) {
+    return isElement(el, "BAL-INPUT-STEPPER");
+};
+var isInput = function(el) {
+    return isElement(el, "BAL-INPUT");
+};
+var isInputDate = function(el) {
+    return isElement(el, "BAL-INPUT-DATE");
+};
+/**
+ * Executes a command on a child element and wraps back to the main element/component
+ */ var wrapOptions = function(options) {
+    return _extends({
+        log: false
+    }, options);
+};
+var wrapCommand = function(displayName, element, message, fn) {
+    return function(selector) {
+        return cy.wrapComponent(element, {
+            log: false
+        }).waitForComponents().find(selector, {
+            log: false
+        }).then(function($el) {
+            Cypress.log({
+                type: "parent",
+                $el: $el,
+                displayName: displayName,
+                message: message
+            });
+            return fn($el);
+        }).wrapComponent(element, {
+            log: false
+        });
+    };
+};
+var shouldLog = function(options) {
+    return options === undefined || options.log !== false;
+};
+var log = function(displayName, message, $el, options) {
+    if (message === void 0) message = "";
+    if (shouldLog(options)) {
+        Cypress.log({
+            type: "parent",
+            $el: $el,
+            displayName: displayName,
+            message: message
+        });
+    }
+};
+var areComponentsReady = function($el) {
+    var queue = [];
+    for(var index = 0; index < $el.length; index++){
+        var element = $el[index];
+        queue.push(deepReady(element, true));
+    }
+    return Promise.all(queue);
+};
+var testOnPlatforms = function(platforms, fn) {
+    var _loop = function(index) {
+        var platform = platforms[index];
+        context("on " + platform, function() {
+            beforeEach(function() {
+                return cy.platform(platform);
+            });
+            fn(platform);
+        });
+    };
+    for(var index = 0; index < platforms.length; index++)_loop(index);
+};
+function checkAriaLabel(element, label) {
+    if (label === undefined || label === null || label === "") {
+        return true;
+    }
+    var ariaLabel = Cypress.$(element).attr("aria-label");
+    var title = Cypress.$(element).attr("title");
+    var text = Cypress.$(element).text().trim();
+    return text === label.trim() || ariaLabel === label.trim() || title === label.trim();
+}
+
+export { hasTestId as A, isSteps as B, _extends as _, waitAfterFramePaint as a, waitAfterIdleCallback as b, checkAriaLabel as c, areComponentsReady as d, deepReady as e, isAccordion as f, isCheckbox as g, isDatepicker as h, isButton as i, isInput as j, isInputDate as k, log as l, isNumberInput as m, isTextarea as n, isSlider as o, isRadio as p, isSelect as q, wrapCommand as r, isTag as s, testOnPlatforms as t, hasClass as u, isHint as v, wrapOptions as w, isLabel as x, isInputStepper as y, isTabs as z };

package/index.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";