@incodetech/web 2.2.0 → 2.3.0-rc.0

package/dist/useCoverMedia-VLw3OYN_.js

@@ -0,0 +1,149 @@
+import { _ as y, h as q } from "./vendor-preact-C0jX1Cbq.js";
+//#region src/hooks/useCoverMedia.ts
+var CONVERGENCE_TIMEOUT_MS = 1e4;
+var CONVERGENCE_INTERVAL_MS = 100;
+var PENDING_CLASS = "IncodeMediaCoverPending";
+/**
+* Returns the explicit box that produces `object-fit: cover` geometry.
+* Kept pure so the visual calculation is independently testable.
+*/
+function calculateCoverMediaGeometry(sourceWidth, sourceHeight, containerWidth, containerHeight) {
+	if (!Number.isFinite(sourceWidth) || !Number.isFinite(sourceHeight) || !Number.isFinite(containerWidth) || !Number.isFinite(containerHeight) || sourceWidth <= 0 || sourceHeight <= 0 || containerWidth <= 0 || containerHeight <= 0) return;
+	const scale = Math.max(containerWidth / sourceWidth, containerHeight / sourceHeight);
+	const width = sourceWidth * scale;
+	const height = sourceHeight * scale;
+	return {
+		width: `${width.toFixed(2)}px`,
+		height: `${height.toFixed(2)}px`,
+		left: `${((containerWidth - width) / 2).toFixed(2)}px`,
+		top: `${((containerHeight - height) / 2).toFixed(2)}px`
+	};
+}
+/**
+* Safari reports `object-fit` support even when its MediaStream paint is
+* incorrect, so CSS.supports cannot detect this bug. Keep the workaround
+* narrowly scoped to the affected iOS/iPadOS 27 WebKit builds instead.
+*/
+function needsExplicitMediaCover(userAgent, platform, maxTouchPoints) {
+	const iosDevice = /\b(?:iPhone|iPad|iPod)\b/.test(userAgent);
+	const iosVersion = userAgent.match(/CPU (?:iPhone )?OS (\d+)[_.]/)?.[1];
+	if (iosDevice && iosVersion === "27") return true;
+	const desktopModeIPad = platform === "MacIntel" && maxTouchPoints > 1;
+	const safariVersion = userAgent.match(/Version\/(\d+)[._]/)?.[1];
+	return desktopModeIPad && safariVersion === "27";
+}
+function isExplicitMediaCoverNeeded() {
+	if (typeof navigator === "undefined") return false;
+	return needsExplicitMediaCover(navigator.userAgent, navigator.platform, navigator.maxTouchPoints);
+}
+/**
+* Applies explicit `cover` geometry only to iOS/iPadOS 27 MediaStream media.
+* Compliant browsers retain native `object-fit: cover`, with no observers,
+* event listeners, polling, or inline geometry.
+*
+* `reattachKey` restarts the workaround when the media source changes. Pass a
+* MediaStream for video and the canvas instance for imperative avatar canvases.
+*/
+function useCoverMedia(mediaRef, reattachKey) {
+	const explicitCoverNeeded = isExplicitMediaCoverNeeded();
+	const applyCover = q(() => {
+		const media = mediaRef.current;
+		const container = media?.parentElement;
+		if (!media || !container) return false;
+		const sourceWidth = media instanceof HTMLVideoElement ? media.videoWidth : media.width;
+		const sourceHeight = media instanceof HTMLVideoElement ? media.videoHeight : media.height;
+		const { width: containerWidth, height: containerHeight } = container.getBoundingClientRect();
+		const geometry = calculateCoverMediaGeometry(sourceWidth, sourceHeight, containerWidth, containerHeight);
+		if (!geometry) return false;
+		if (media.style.width === geometry.width && media.style.height === geometry.height && media.style.left === geometry.left && media.style.top === geometry.top) return true;
+		media.style.maxWidth = "none";
+		media.style.maxHeight = "none";
+		media.style.right = "auto";
+		media.style.bottom = "auto";
+		media.style.width = geometry.width;
+		media.style.height = geometry.height;
+		media.style.left = geometry.left;
+		media.style.top = geometry.top;
+		return true;
+	}, [mediaRef]);
+	y(() => {
+		if (!explicitCoverNeeded) return;
+		const media = mediaRef.current;
+		if (!media) return;
+		const cleanups = [];
+		media.classList.add(PENDING_CLASS);
+		cleanups.push(() => media.classList.remove(PENDING_CLASS));
+		const reveal = () => media.classList.remove(PENDING_CLASS);
+		let pollId;
+		let timeoutId;
+		const stopPolling = () => {
+			if (pollId !== void 0) {
+				clearInterval(pollId);
+				pollId = void 0;
+			}
+			if (timeoutId !== void 0) {
+				clearTimeout(timeoutId);
+				timeoutId = void 0;
+			}
+		};
+		cleanups.push(stopPolling);
+		const tryApply = () => {
+			const applied = applyCover();
+			if (applied) {
+				reveal();
+				stopPolling();
+			}
+			return applied;
+		};
+		let frame1 = 0;
+		let frame2 = 0;
+		const applyCoverSettled = () => {
+			tryApply();
+			cancelAnimationFrame(frame1);
+			cancelAnimationFrame(frame2);
+			frame1 = requestAnimationFrame(() => {
+				tryApply();
+				frame2 = requestAnimationFrame(tryApply);
+			});
+		};
+		if (media instanceof HTMLVideoElement) for (const event of ["loadedmetadata", "resize"]) {
+			media.addEventListener(event, applyCoverSettled);
+			cleanups.push(() => media.removeEventListener(event, applyCoverSettled));
+		}
+		if (typeof ResizeObserver !== "undefined") {
+			const observer = new ResizeObserver(() => tryApply());
+			const container = media.parentElement;
+			if (container) observer.observe(container);
+			observer.observe(media);
+			cleanups.push(() => observer.disconnect());
+		}
+		window.addEventListener("resize", applyCoverSettled);
+		window.addEventListener("orientationchange", applyCoverSettled);
+		cleanups.push(() => {
+			window.removeEventListener("resize", applyCoverSettled);
+			window.removeEventListener("orientationchange", applyCoverSettled);
+		});
+		const startPolling = () => {
+			pollId = setInterval(tryApply, CONVERGENCE_INTERVAL_MS);
+			timeoutId = setTimeout(() => {
+				stopPolling();
+				reveal();
+			}, CONVERGENCE_TIMEOUT_MS);
+		};
+		if (!tryApply()) startPolling();
+		applyCoverSettled();
+		return () => {
+			cancelAnimationFrame(frame1);
+			cancelAnimationFrame(frame2);
+			for (const cleanup of cleanups) cleanup();
+		};
+	}, [
+		applyCover,
+		explicitCoverNeeded,
+		mediaRef,
+		reattachKey
+	]);
+	return applyCover;
+}
+//#endregion
+export { useCoverMedia as t };

package/dist/useModuleLoader-DpcbSKBH.js

@@ -0,0 +1,176 @@
+import { _ as y, c as A, f as d } from "./vendor-preact-C0jX1Cbq.js";
+//#region src/modules/flow/headlessModule.ts
+var HeadlessWorkflowModule = () => null;
+var lazyHeadlessWorkflowModule = () => Promise.resolve(HeadlessWorkflowModule);
+var HEADLESS_WORKFLOW_MODULE_KEYS = new Set(["IDENTITY_SEARCH"]);
+//#endregion
+//#region src/modules/flow/useModuleLoader.ts
+function getLoadErrorMessage(error, fallbackMessage) {
+	return error instanceof Error ? error.message : fallbackMessage;
+}
+var loadedComponents = /* @__PURE__ */ new WeakMap();
+var inflightLoaders = /* @__PURE__ */ new WeakMap();
+function getLoaderKey(loader) {
+	return loader;
+}
+function getCachedComponent(loader) {
+	if (!loader) return void 0;
+	return loadedComponents.get(getLoaderKey(loader));
+}
+function loadComponent(loader) {
+	const key = getLoaderKey(loader);
+	const cached = loadedComponents.get(key);
+	if (cached) return Promise.resolve(cached);
+	const inflight = inflightLoaders.get(key);
+	if (inflight) return inflight;
+	const promise = loader().then((Component) => {
+		loadedComponents.set(key, Component);
+		inflightLoaders.delete(key);
+		return Component;
+	}).catch((error) => {
+		inflightLoaders.delete(key);
+		throw error;
+	});
+	inflightLoaders.set(key, promise);
+	return promise;
+}
+function computeInitialState(loader) {
+	if (!loader) return { status: "idle" };
+	const cached = getCachedComponent(loader);
+	if (cached) return {
+		status: "loaded",
+		Component: cached
+	};
+	return { status: "loading" };
+}
+function resolveModuleLoader(moduleKey, modules, headlessModuleKeys) {
+	if (!moduleKey) return void 0;
+	return modules[moduleKey] ?? (headlessModuleKeys?.has(moduleKey) ? lazyHeadlessWorkflowModule : void 0);
+}
+function useLazyComponentLoader(options) {
+	const { loader, onLoading, onLoaded, onError } = options;
+	const [state, setState] = d(() => computeInitialState(loader));
+	const prevLoaderRef = A(loader);
+	const onLoadingRef = A(onLoading);
+	const onLoadedRef = A(onLoaded);
+	const onErrorRef = A(onError);
+	y(() => {
+		onLoadingRef.current = onLoading;
+		onLoadedRef.current = onLoaded;
+		onErrorRef.current = onError;
+	}, [
+		onLoading,
+		onLoaded,
+		onError
+	]);
+	if (prevLoaderRef.current !== loader) {
+		prevLoaderRef.current = loader;
+		setState(computeInitialState(loader));
+	}
+	y(() => {
+		if (!loader) return;
+		if (getCachedComponent(loader)) {
+			onLoadedRef.current?.();
+			return;
+		}
+		onLoadingRef.current?.();
+		let cancelled = false;
+		loadComponent(loader).then((Component) => {
+			if (!cancelled) {
+				setState({
+					status: "loaded",
+					Component
+				});
+				onLoadedRef.current?.();
+			}
+		}).catch((error) => {
+			if (!cancelled) {
+				const errorMessage = getLoadErrorMessage(error, "Failed to load component");
+				setState({
+					status: "error",
+					error: errorMessage
+				});
+				onErrorRef.current?.(errorMessage);
+			}
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [loader]);
+	return state;
+}
+function useModuleLoader(options) {
+	const { moduleKey, modules, headlessModuleKeys, onModuleLoading, onModuleLoaded, onError } = options;
+	const [unsupportedModuleKey, setUnsupportedModuleKey] = d(void 0);
+	const loader = resolveModuleLoader(moduleKey, modules, headlessModuleKeys);
+	const state = useLazyComponentLoader({
+		loader,
+		onLoading: moduleKey ? () => onModuleLoading?.(moduleKey) : void 0,
+		onLoaded: moduleKey ? () => onModuleLoaded?.(moduleKey) : void 0,
+		onError: moduleKey ? (errorMessage) => onError?.(`Failed to load ${moduleKey}: ${errorMessage}`) : void 0
+	});
+	y(() => {
+		if (!moduleKey) {
+			setUnsupportedModuleKey(void 0);
+			return;
+		}
+		if (!loader) setUnsupportedModuleKey(moduleKey);
+		else setUnsupportedModuleKey(void 0);
+	}, [loader, moduleKey]);
+	if (!moduleKey) return { status: "idle" };
+	if (unsupportedModuleKey) return {
+		status: "unsupported",
+		moduleKey: unsupportedModuleKey
+	};
+	if (state.status === "idle" || state.status === "loading") return {
+		status: "loading",
+		moduleKey
+	};
+	if (state.status === "error") return {
+		status: "error",
+		moduleKey,
+		error: state.error
+	};
+	return {
+		status: "loaded",
+		moduleKey,
+		Component: state.Component
+	};
+}
+function useModulePreloader(options) {
+	const { moduleKey, modules } = options;
+	const loader = moduleKey ? modules[moduleKey] : void 0;
+	const state = useLazyComponentLoader({ loader });
+	return loader != null && state.status === "loaded";
+}
+function schedulePrefetch(run) {
+	if (typeof requestIdleCallback !== "undefined") requestIdleCallback(() => {
+		run();
+	});
+	else setTimeout(run, 0);
+}
+function usePrefetchNextModule(steps, currentStepIndex, modules, currentModuleLoaded) {
+	const prefetchedRef = A(/* @__PURE__ */ new Set());
+	y(() => {
+		if (!currentModuleLoaded) return;
+		if (currentStepIndex < steps.length - 1) {
+			const nextStep = steps[currentStepIndex + 1];
+			if (nextStep && !prefetchedRef.current.has(nextStep)) {
+				prefetchedRef.current.add(nextStep);
+				const loader = modules[nextStep];
+				if (loader) schedulePrefetch(() => {
+					loader().catch(() => {
+						prefetchedRef.current.delete(nextStep);
+					});
+				});
+			}
+		}
+	}, [
+		steps,
+		currentStepIndex,
+		modules,
+		currentModuleLoaded
+	]);
+}
+//#endregion
+export { HEADLESS_WORKFLOW_MODULE_KEYS as a, usePrefetchNextModule as i, useModuleLoader as n, useModulePreloader as r, useLazyComponentLoader as t };