@sbb-esta/lyne-elements 5.0.2 → 5.2.0

package/development/core/testing.js

@@ -1,6 +1,177 @@
-import { EventSpy } from "./testing/event-spy.js";
-import { describeIf, testIf } from "./testing/mocha-extensions.js";
-import { waitForCondition } from "./testing/wait-for-condition.js";
-import { waitForImageReady } from "./testing/wait-for-image-ready.js";
-import { isReactiveElement, waitForLitRender } from "./testing/wait-for-render.js";
-export { EventSpy, describeIf, isReactiveElement, testIf, waitForCondition, waitForImageReady, waitForLitRender };
+import { isServer } from "lit";
+
+//#region src/elements/core/testing/event-spy.ts
+/**
+* This class exists to facilitate the test migration from stencil to lit.
+* It mimics the API that stencil provided to test events.
+*/
+var EventSpy = class {
+	get count() {
+		return this._count;
+	}
+	get events() {
+		return this._events;
+	}
+	get firstEvent() {
+		return this.events.length ? this.events[0] : null;
+	}
+	get lastEvent() {
+		return this.events.length ? this.events[this.events.length - 1] : null;
+	}
+	constructor(_event, _target = null, _options = null) {
+		this._event = _event;
+		this._target = _target;
+		this._options = _options;
+		this._count = 0;
+		this._events = [];
+		this._promiseEventMap = /* @__PURE__ */ new Map();
+		if (!this._target) this._target = document;
+		this._listenForEvent();
+	}
+	calledOnce(timeout) {
+		return this.calledTimes(1, timeout);
+	}
+	calledTimes(count, timeout = 2e3) {
+		if (this.count > count) return Promise.reject(`Event '${this._event}' has been emitted more than expected (expected ${count}, actual ${this.count}`);
+		else if (this.count === count) return Promise.resolve(this.events[count - 1]);
+		else if (this._promiseEventMap.has(count)) return this._promiseEventMap.get(count).promise;
+		else {
+			let resolve;
+			let reject;
+			const promiseWithExecutor = {
+				promise: new Promise((resolveFunction, rejectFunction) => {
+					resolve = resolveFunction;
+					reject = rejectFunction;
+				}),
+				resolve,
+				reject
+			};
+			this._promiseEventMap.set(count, promiseWithExecutor);
+			return this._wrapPromiseWithTimeout(promiseWithExecutor, count, timeout);
+		}
+	}
+	_wrapPromiseWithTimeout(promiseWithExecutor, count, timeout) {
+		const clearTimeoutId = setTimeout(() => promiseWithExecutor.reject(`awaiting calledTimes(${count}) for event '${this._event}' results in timeout`), timeout);
+		promiseWithExecutor.promise.then(() => clearTimeout(clearTimeoutId));
+		return promiseWithExecutor.promise;
+	}
+	_listenForEvent() {
+		this._target?.addEventListener(this._event, (ev) => {
+			this._events.push(ev);
+			this._count++;
+			this._promiseEventMap.get(this.count)?.resolve(ev);
+		}, this._options ?? void 0);
+	}
+};
+
+//#endregion
+//#region src/elements/core/testing/mocha-extensions.ts
+/**
+* Skip the `describe` if the condition is not met
+*/
+const describeIf = (condition, title, fn) => {
+	if (condition) return Mocha.describe(title, fn);
+};
+/**
+* Skip the `test` if the condition is not met
+*/
+const testIf = (condition, title, fn) => {
+	if (condition) return Mocha.test(title, fn);
+};
+
+//#endregion
+//#region src/elements/core/testing/wait-for-condition.ts
+async function waitForCondition(condition, interval = 30, timeoutInMilliseconds = 2 * 1e3) {
+	const start = /* @__PURE__ */ new Date();
+	let counter = 0;
+	function checkCondition() {
+		counter++;
+		return condition();
+	}
+	while (!await checkCondition() && start.getTime() + timeoutInMilliseconds >= (/* @__PURE__ */ new Date()).getTime()) await new Promise((resolve) => setTimeout(resolve, interval));
+	if (start.getTime() + timeoutInMilliseconds < (/* @__PURE__ */ new Date()).getTime()) return Promise.reject(`waitForCondition timeout: ${condition.toString()}, attempts: ${counter}, start: ${start.getTime()}, end: ${(/* @__PURE__ */ new Date()).getTime()}`);
+	return Promise.resolve(true);
+}
+
+//#endregion
+//#region src/elements/core/dom/platform.ts
+let hasV8BreakIterator;
+try {
+	hasV8BreakIterator = typeof Intl !== "undefined" && Intl.v8BreakIterator;
+} catch {
+	hasV8BreakIterator = false;
+}
+/** Whether the current browser is Microsoft Edge. */
+const isEdge = !isServer && /(edge)/i.test(navigator.userAgent);
+/** Whether the current rendering engine is Microsoft Trident. */
+const isTrident = !isServer && /(msie|trident)/i.test(navigator.userAgent);
+/** Whether the current rendering engine is Blink. */
+const isBlink = !isServer && !!(window.chrome || hasV8BreakIterator) && typeof CSS !== "undefined" && !isEdge && !isTrident;
+/** Whether the current rendering engine is WebKit. */
+const isWebkit = !isServer && /AppleWebKit/i.test(navigator.userAgent) && !isBlink && !isEdge && !isTrident;
+/** Whether the current platform is Apple iOS. */
+const isIOS = !isServer && /iPad|iPhone|iPod/.test(navigator.userAgent) && !("MSStream" in window);
+/**
+* Whether the device is a mac.
+* @experimental Avoid using this as this is not reliable.
+*/
+const isMacOS = !isServer && /(Mac)/i.test(navigator.platform);
+/** Whether the current browser is Firefox. */
+const isFirefox = !isServer && /(firefox|minefield)/i.test(navigator.userAgent);
+/** Whether the current platform is Android. */
+const isAndroid = !isServer && /android/i.test(navigator.userAgent) && !isTrident;
+/** Whether the current browser is Safari. */
+const isSafari = !isServer && /safari/i.test(navigator.userAgent) && isWebkit;
+
+//#endregion
+//#region src/elements/core/testing/wait-for-image-ready.ts
+async function waitForImageReady(element, timeoutInMilliseconds = 2 * 1e3) {
+	const imgElement = element.localName === "sbb-image" ? element.shadowRoot?.querySelector(".sbb-image__img") ?? null : element;
+	if (!imgElement) throw new Error("img tag not found");
+	if (!imgElement.complete) await new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => reject("image loading timeout"), timeoutInMilliseconds);
+		imgElement.addEventListener("load", () => {
+			clearTimeout(timeout);
+			if (!imgElement.complete || isSafari) imgElement.decode().then(() => resolve());
+			else resolve();
+		});
+		imgElement.addEventListener("error", () => {
+			clearTimeout(timeout);
+			reject("image error");
+		});
+	});
+	else if (isSafari) await imgElement.decode();
+}
+
+//#endregion
+//#region src/elements/core/testing/wait-for-render.ts
+/**
+* Tests if an element is a Lit `ReactiveElement`.
+*
+* @param element the element to test.
+* @return true if the element is a `ReactiveElement`.
+*/
+const isReactiveElement = (element) => {
+	return Boolean(element.updateComplete);
+};
+const promiseComplete = Promise.resolve();
+/**
+* Waits for all Lit `ReactiveElement` children of the given parent node to
+* finish rendering.
+*
+* @param node a parent node to wait for rendering on.
+*/
+const waitForLitRender = async (node) => {
+	const root = await node;
+	(root.parentElement ?? root).querySelectorAll?.("[defer-hydration]").forEach((e) => e.removeAttribute("defer-hydration"));
+	const completables = [root, ...root.querySelectorAll("*")].filter(isReactiveElement).map((e) => [
+		e.updateComplete,
+		e.hydrationComplete ?? promiseComplete,
+		waitForLitRender(e.renderRoot)
+	]).flat(Infinity);
+	await Promise.all(completables);
+	return root;
+};
+
+//#endregion
+export { EventSpy, describeIf, isReactiveElement, testIf, waitForCondition, waitForImageReady, waitForLitRender };

package/development/core.d.ts

@@ -61,4 +61,3 @@ export * from './core/overlay/overlay-outside-pointer-event-listener.ts';
 export * from './core/overlay/overlay-trigger-attributes.ts';
 export * from './core/overlay/position.ts';
 export * from './core/styles/styles.ts';
-//# sourceMappingURL=core.d.ts.map