@incodetech/core 2.2.0-rc.8 → 2.3.0-rc.0

package/dist/openviduLazy-CCDpFWg1.esm.js

@@ -1,10 +0,0 @@
-import { a as __toESM } from "./rolldown-runtime-FZ4Itg2g.esm.js";
-//#region ../infra/src/providers/browser/openviduLazy.ts
-let openViduImport;
-async function loadOpenVidu() {
-	if (openViduImport) return openViduImport;
-	openViduImport = import("./lib-DAyUtOTj.esm.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
-	return openViduImport;
-}
-//#endregion
-export { loadOpenVidu };

package/dist/recordingService-BRgmVnUT.esm.js

@@ -1,329 +0,0 @@
-import { t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
-import { d as stopRecording, g as uploadDeepsightVideo, u as startRecordingSession } from "./onDeviceFaceResults-CB62pUQf.esm.js";
-import { t as getAdaptiveMediaRecorderOptions } from "./mediaRecorderOptions-dALSV8af.esm.js";
-//#region ../infra/src/media/VideoTrimmer.ts
-async function getDurationBySeek(videoBlob) {
-	const video = document.createElement("video");
-	video.preload = "metadata";
-	video.src = URL.createObjectURL(videoBlob);
-	try {
-		if (!Number.isFinite(video.duration)) {
-			video.currentTime = Number.MAX_SAFE_INTEGER;
-			await new Promise((resolve) => {
-				const onDurationChange = () => {
-					if (Number.isFinite(video.duration)) {
-						video.removeEventListener("durationchange", onDurationChange);
-						video.removeEventListener("timeupdate", onTimeUpdate);
-						resolve(video.duration);
-					}
-				};
-				const onTimeUpdate = () => {
-					if (Number.isFinite(video.duration)) {
-						video.removeEventListener("timeupdate", onTimeUpdate);
-						video.removeEventListener("durationchange", onDurationChange);
-						resolve(video.duration);
-					}
-				};
-				video.addEventListener("durationchange", onDurationChange);
-				video.addEventListener("timeupdate", onTimeUpdate);
-			});
-		}
-		const duration = video.duration;
-		return Number.isFinite(duration) ? duration : null;
-	} finally {
-		URL.revokeObjectURL(video.src);
-		video.src = "";
-	}
-}
-async function trimLastNSecondsUsingPlayback(videoBlob, seconds) {
-	const video = document.createElement("video");
-	video.preload = "metadata";
-	video.playsInline = true;
-	video.muted = true;
-	const videoURL = URL.createObjectURL(videoBlob);
-	video.src = videoURL;
-	const duration = await getDurationBySeek(videoBlob);
-	if (!duration || duration < seconds) {
-		URL.revokeObjectURL(videoURL);
-		return videoBlob;
-	}
-	const startTime = Math.max(0, Math.floor(duration) - seconds);
-	await new Promise((resolve) => {
-		if (video.readyState >= 2) resolve();
-		else video.addEventListener("loadedmetadata", () => resolve(), { once: true });
-	});
-	const canvas = document.createElement("canvas");
-	canvas.width = 230;
-	canvas.height = 320;
-	const captureFps = isAndroid() ? 15 : 24;
-	const stream = canvas.captureStream(captureFps);
-	const ctx = canvas.getContext("2d");
-	video.currentTime = startTime;
-	await new Promise((resolve) => {
-		video.addEventListener("seeked", () => resolve(), { once: true });
-	});
-	ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-	const mimeType = videoBlob.type || (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "video/mp4");
-	const mediaRecorder = new MediaRecorder(stream.clone(), {
-		mimeType,
-		videoBitsPerSecond: 5e5,
-		bitsPerSecond: 5e5
-	});
-	const chunks = [];
-	mediaRecorder.ondataavailable = (event) => {
-		if (event.data.size > 0) chunks.push(event.data);
-	};
-	const recordingPromise = new Promise((resolve) => {
-		mediaRecorder.onstop = () => {
-			const trimmedBlob = new Blob(chunks, { type: mimeType });
-			URL.revokeObjectURL(videoURL);
-			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
-			stream.getTracks().forEach((track) => track.stop());
-			video.src = "";
-			resolve(trimmedBlob);
-		};
-	});
-	video.addEventListener("play", () => {
-		function drawVideo() {
-			if (video.currentTime >= duration) {
-				mediaRecorder.stop();
-				video.pause();
-				return;
-			}
-			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-			requestAnimationFrame(drawVideo);
-		}
-		drawVideo();
-		setTimeout(() => {
-			mediaRecorder.start(100);
-		}, 500);
-	});
-	video.play().catch(() => {
-		URL.revokeObjectURL(videoURL);
-	});
-	const trimmedBlob = await recordingPromise;
-	console.timeEnd("trimLastNSecondsUsingPlayback");
-	return trimmedBlob;
-}
-async function trimLastNSeconds(videoBlob, seconds) {
-	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
-}
-//#endregion
-//#region ../infra/src/providers/browser/LocalRecordingProvider.ts
-function toBase64(videoBlob) {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onloadend = () => {
-			const base64 = reader.result.split(",")[1];
-			resolve(base64);
-		};
-		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("FileReader error"));
-		reader.readAsDataURL(videoBlob);
-	});
-}
-var LocalRecordingProvider = class {
-	constructor() {
-		this.mediaRecorder = null;
-		this._isRecording = false;
-		this._hasError = false;
-		this._error = null;
-		this.mimeType = "";
-		this.stream = null;
-		this.pauseRecordingBound = this.pauseRecording.bind(this);
-	}
-	get isRecording() {
-		return this._isRecording;
-	}
-	get hasError() {
-		return this._hasError;
-	}
-	get error() {
-		return this._error;
-	}
-	startRecording(stream) {
-		this.reset();
-		this.registerEventListeners();
-		this.stream = stream;
-		try {
-			const options = getAdaptiveMediaRecorderOptions();
-			this.mimeType = options.mimeType;
-			const recorder = new MediaRecorder(stream.clone(), options);
-			recorder.onerror = (event) => {
-				this._error = `Recording error: ${event}`;
-				this._isRecording = false;
-				this._hasError = true;
-			};
-			recorder.start();
-			this.mediaRecorder = recorder;
-			this._isRecording = true;
-			this._error = null;
-			this._hasError = false;
-		} catch (err) {
-			this._error = `Failed to start recording: ${err}`;
-			this._hasError = true;
-		}
-	}
-	async stopRecording(trimSeconds, encrypt, generateChecksum) {
-		const recorder = this.mediaRecorder;
-		return new Promise((resolve, reject) => {
-			this.removeEventListeners();
-			if (recorder && this._isRecording) {
-				const chunks = [];
-				recorder.ondataavailable = (event) => {
-					if (event.data.size > 0) chunks.push(event.data);
-				};
-				recorder.onstop = async () => {
-					try {
-						const trimmedVideo = await trimLastNSeconds(new Blob(chunks, { type: this.mimeType }), trimSeconds);
-						const encryptedVideoBase64 = encrypt(await toBase64(trimmedVideo));
-						generateChecksum(await trimmedVideo.arrayBuffer());
-						this._isRecording = false;
-						resolve({
-							trimmedBlob: trimmedVideo,
-							encryptedVideo: encryptedVideoBase64
-						});
-					} catch (error) {
-						this._isRecording = false;
-						this._error = `Recording stop failed: ${error}`;
-						this._hasError = true;
-						reject(error);
-					}
-				};
-				recorder.stop();
-				this._isRecording = false;
-			} else resolve({
-				trimmedBlob: new Blob([], { type: this.mimeType }),
-				encryptedVideo: ""
-			});
-			recorder?.stream?.getTracks().forEach((track) => track.stop());
-		});
-	}
-	reset() {
-		this._isRecording = false;
-		this._error = null;
-		this._hasError = false;
-	}
-	pauseRecording() {
-		if (!this._isRecording) return;
-		if (this.mediaRecorder?.state === "recording") try {
-			this.mediaRecorder.pause();
-		} catch {}
-	}
-	registerEventListeners() {
-		document.addEventListener("visibilitychange", this.pauseRecordingBound);
-	}
-	removeEventListeners() {
-		document.removeEventListener("visibilitychange", this.pauseRecordingBound);
-	}
-};
-//#endregion
-//#region src/internal/faceCapture/recordingService.ts
-let openViduProviderImportPromise;
-let openViduBrowserImportPromise;
-function loadOpenViduProviderModule() {
-	if (!openViduProviderImportPromise) openViduProviderImportPromise = import("./OpenViduRecordingProvider-Du98qevC.esm.js");
-	return openViduProviderImportPromise;
-}
-function loadOpenViduBrowserModule() {
-	if (!openViduBrowserImportPromise) openViduBrowserImportPromise = (async () => {
-		return (await import("./openviduLazy-CCDpFWg1.esm.js")).loadOpenVidu();
-	})();
-	return openViduBrowserImportPromise;
-}
-function preloadOpenViduProvider() {
-	loadOpenViduProviderModule();
-	loadOpenViduBrowserModule();
-}
-/**
-* Records on-device and uploads encrypted video for liveness.
-*/
-var LocalRecordingService = class {
-	constructor(wasmUtil, sessionToken) {
-		this.recorder = new LocalRecordingProvider();
-		this.sessionToken = sessionToken;
-		this.wasmUtil = wasmUtil;
-	}
-	async start(stream) {
-		this.recorder.startRecording(stream);
-		this.wasmUtil.osv();
-	}
-	async stop() {
-		if (!this.recorder.isRecording) return { recordingId: null };
-		this.wasmUtil.oev();
-		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
-		if (!this.sessionToken) return { recordingId: null };
-		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
-	}
-	async stopAndGetVideo() {
-		if (!this.recorder.isRecording) return { videoBase64: void 0 };
-		try {
-			this.wasmUtil.oev();
-			const videoBase64 = (await this.recorder.stopRecording(10, (base64) => base64, () => {})).encryptedVideo;
-			return { videoBase64: videoBase64 ? videoBase64 : void 0 };
-		} catch {
-			return { videoBase64: void 0 };
-		}
-	}
-	cleanup() {
-		this.recorder.reset();
-	}
-};
-/**
-* Records through OpenVidu and manages the session lifecycle.
-*/
-var OpenViduRecordingService = class {
-	constructor(config) {
-		this.config = config;
-	}
-	async start(stream) {
-		if (!this.provider) {
-			const { OpenViduRecordingProvider } = await loadOpenViduProviderModule();
-			this.provider = new OpenViduRecordingProvider();
-		}
-		const sessionConfig = {
-			...this.config,
-			recording: { capability: this.provider }
-		};
-		this.session = await startRecordingSession({
-			config: sessionConfig,
-			clonedStream: stream.clone(),
-			existing: this.session
-		});
-	}
-	async stop() {
-		if (this.session) {
-			stopRecording(this.session);
-			this.session = void 0;
-		}
-		return { recordingId: null };
-	}
-	async stopAndGetVideo() {
-		if (this.session) {
-			stopRecording(this.session);
-			this.session = void 0;
-		}
-		return { videoBase64: void 0 };
-	}
-	cleanup() {
-		if (this.session) stopRecording(this.session);
-	}
-};
-/**
-* Creates the recording service for the current configuration.
-*
-* Order of precedence:
-* 1. `onDeviceFaceResultsSubmissionEnabled === true` → no recording. The
-*    on-device workflow never uploads media, only the staged face-results
-*    JSON via `WebApi.postFaceResults`. Mirrors V1's
-*    `FaceFlowManager.setRecorders()` early return.
-* 2. `deepsightLiveness === 'VIDEOLIVENESS'` → local Deepsight recorder.
-* 3. `enableFaceRecording === true` → server-side OpenVidu recorder.
-* 4. otherwise → no recording.
-*/
-function createRecordingService(params) {
-	if (params.config.onDeviceFaceResultsSubmissionEnabled === true) return;
-	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
-	if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
-}
-//#endregion
-export { preloadOpenViduProvider as n, createRecordingService as t };