@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/{idCaptureManager-DASPUMtC.esm.js → idCaptureManager-BjiBSrHm.esm.js}

@@ -1,15 +1,111 @@
-import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-Ch0mFJNT.esm.js";
-import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-GBS6XSii.esm.js";
-import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-C_kxhNeo.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CBHBhKQN.esm.js";
-import { i as mapIdManualUploadScreenName, n as getManualUploadTabs, r as MAX_EXPIRED_FIRST_SIDE_ATTEMPTS, t as idCaptureMachine, v as mapDigitalIdScreenName } from "./idCaptureStateMachine-DZ2ZTSxu.esm.js";
-
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-BqUCwLY8.esm.js";
+import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BX1BiLDK.esm.js";
+import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-UvUcOSRb.esm.js";
+import { n as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-CRwQh8jc.esm.js";
+import { m as resolveIdCaptureThresholds, p as resolveCaptureResultPreviewTreatment } from "./idCaptureServices-CFDwqTtQ.esm.js";
+//#region src/modules/id/digitalUpload/instrumentation.ts
+const TERMINAL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
+function isHoldingState(value) {
+	if (value === "holding") return true;
+	if (typeof value !== "object" || value === null) return false;
+	const uploadingState = value.uploading;
+	if (uploadingState === "holding") return true;
+	if (typeof uploadingState === "object" && uploadingState !== null) return Object.prototype.hasOwnProperty.call(uploadingState, "holding");
+	return false;
+}
+/**
+* Maps a Digital ID Upload child-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: Upload Digital ID Figma file
+* (`https://www.figma.com/design/wxFsHRvllern4VnjRqM4JO/Upload-Digital-ID---Latest-Design?node-id=25911-4095`).
+*
+* Family is `uploadDigitalid.*` — emitted cross-family under the parent
+* `idCapture` module token. Returns Figma-verbatim strings which the
+* adapter emits as-is on `event.screen` (e.g.
+* `uploadDigitalid.<section>.<state>`). See
+* `docs/patterns/INSTRUMENTATION.md`.
+*/
+function mapDigitalIdScreenName(value, failReason) {
+	if (value === "tutorial") return "uploadDigitalid.tutorial.default";
+	if (value === "selecting" || value === "reviewing") return "uploadDigitalid.review.default";
+	if (value === "uploading" || isHoldingState(value)) return "uploadDigitalid.analyzing.default";
+	if (value === "success") return "uploadDigitalid.success.default";
+	if (value === "fileTooLarge") return "uploadDigitalid.error.filetoolarge";
+	if (value === "error") {
+		if (failReason !== null && TERMINAL_REASONS.has(failReason)) return "uploadDigitalid.error.notaccepted";
+		return "uploadDigitalid.error.default";
+	}
+	return "uploadDigitalid.review.default";
+}
+//#endregion
+//#region src/modules/id/manualUpload/instrumentation.ts
+/**
+* Maps an ID Manual Upload child-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: ID Manual Upload Figma file
+* (`https://www.figma.com/design/WCx6d4zXG5nu946mu0KZNO/ID-Manual-Upload---Latest-Design?node-id=2462-18986`).
+*
+* Family is `IDmanual.*` — emitted cross-family under the parent
+* `idCapture` module token (same precedent as `uploadDigitalid.*` from
+* the digital-upload sub-flow). Manual upload has no standalone manager
+* or module token of its own.
+*
+* The mapper returns Figma-verbatim strings (e.g.
+* `'IDmanual.upload.uploadedFrontandBack'`) which the adapter emits as-is
+* on `event.screen`. See `docs/patterns/INSTRUMENTATION.md`.
+*
+* In-scope Figma screens (driven from child SM state + context):
+*
+* - `IDmanual.upload.default` — selecting, ID tab, no front file yet
+* - `IDmanual.upload.uploadedFront` — selecting, ID tab, front uploaded,
+*   back still needed
+* - `IDmanual.upload.uploadedFrontandBack` — selecting, ID tab, both
+*   sides uploaded (or `onlyFront`/`skipBackFromServer` short-circuit)
+* - `IDmanual.upload.passport` — selecting, passport tab, no file
+* - `IDmanual.upload.uploadedPassport` — selecting, passport tab,
+*   passport uploaded
+* - `IDmanual.error.document` — selecting, with a populated
+*   `errorMessage`
+*
+* Figma screens intentionally NOT mapped here (parent-level surfaces or
+* shared with other families):
+*
+* - `IDmanual.documentchooser.default` / `IDmanual.howtoverify` —
+*   the chooser and the "how to verify" tutorial are PARENT-LEVEL
+*   `idCapture` surfaces (one shared React component, fired BEFORE the
+*   user picks manual-vs-digital). The Upload Digital ID canvas
+*   describes the same physical pixels under its own family name.
+*   Decision (Option A, recorded in `.cursor/commands/sync-events.md`):
+*   keep emitting the neutral parent names `idCapture.documentchooser`
+*   and `idCapture.tutorial.{front,back,passport}` and treat the
+*   per-canvas Figma names as design-side aliases. Per-flow attribution
+*   would require a `selectedDocumentType`-aware override at the parent
+*   dispatcher — explicitly NOT shipped here.
+* - `digitalID.success.default` — appears on the canvas for reference,
+*   but the actual success surface is emitted by `mapDigitalIdScreenName`
+*   as `uploadDigitalid.success.default`. Manual upload has no dedicated
+*   success screen; `finished` returns control to the parent SM.
+*
+* Returns `undefined` for transient (`uploadingFront`/`uploadingBack`/
+* `uploadingPassport`/`checkRetries`) and terminal (`retriesExhausted`/
+* `exhausted`/`finished`) states — the parent dispatcher falls back to
+* its existing default (`idCapture.manualIdUpload`) for those beats.
+*/
+function mapIdManualUploadScreenName(value, context) {
+	if (value !== "selecting" || context === void 0) return;
+	if (context.errorMessage !== null) return "IDmanual.error.document";
+	if (context.activeTab === "passport") return context.passportUploaded ? "IDmanual.upload.uploadedPassport" : "IDmanual.upload.passport";
+	if (!context.frontUploaded) return "IDmanual.upload.default";
+	if (context.backUploaded || context.skipBackFromServer || context.onlyFront) return "IDmanual.upload.uploadedFrontandBack";
+	return "IDmanual.upload.uploadedFront";
+}
+//#endregion
 //#region src/internal/idCapture/idCaptureManagerFactory.ts
 function getPermissionStatus(snapshot) {
 	if (!snapshot.matches("permissions")) return;
-	if (snapshot.matches({ permissions: "idle" })) return "idle";
+	if (snapshot.matches({ permissions: "idle" })) return "checking";
 	if (snapshot.matches({ permissions: "waitingForUser" })) return "idle";
 	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
 	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
@@ -23,14 +119,21 @@ function getCaptureStatus(snapshot) {
 		manualCaptureWaiting: snapshot.matches({ capture: "manualCaptureWaiting" }),
 		capturing: snapshot.matches({ capture: "capturing" }),
 		capturingManual: snapshot.matches({ capture: "capturingManual" }),
+		capturingBarcode: snapshot.matches({ capture: "capturingBarcode" }),
+		submittingBarcodePreCapture: snapshot.matches({ capture: "submittingBarcodePreCapture" }),
+		resultPreview: snapshot.matches({ capture: "resultPreview" }),
 		uploading: snapshot.matches({ capture: "uploading" }),
+		uploadCompleted: snapshot.matches({ capture: "uploadCompleted" }),
+		submittingBarcode: snapshot.matches({ capture: "submittingBarcode" }),
 		uploadError: snapshot.matches({ capture: "uploadError" }),
 		success: snapshot.matches({ capture: "success" })
 	};
 	if (matches.initializing) return "initializing";
 	if (matches.detecting || matches.manualCaptureWaiting) return "detecting";
+	if (matches.capturingBarcode || matches.submittingBarcodePreCapture) return "holdOn";
 	if (matches.capturing || matches.capturingManual) return "capturing";
-	if (matches.uploading) return "uploading";
+	if (matches.uploading || matches.uploadCompleted || matches.submittingBarcode) return "uploading";
+	if (matches.resultPreview) return "resultPreview";
 	if (matches.uploadError) return "uploadError";
 	if (matches.success) return "success";
 }
@@ -113,7 +216,6 @@ function mapCaptureState(snapshot, context) {
 		captureStatus,
 		stream: context.stream,
 		detectionStatus: context.detectionStatus,
-		debugFrame: void 0,
 		attemptsRemaining: context.attemptsRemaining,
 		uploadError,
 		currentMode: context.currentMode,
@@ -121,8 +223,10 @@ function mapCaptureState(snapshot, context) {
 		orientation: context.orientation,
 		idType: context.idType,
 		previewImageUrl: context.previewImageUrl,
+		barcodeFastPathCaptured: context.barcodeFastPathCaptured,
 		uploadProgress: context.uploadProgress ?? 0,
 		ageAssurance: context.config.ageAssurance === true,
+		captureFeedbackMode: context.captureFeedbackMode,
 		uploadErrorMessage: uploadError ? getErrorTitleKey(uploadError, context.currentMode) : void 0,
 		uploadErrorDescription: uploadError ? getErrorSubtitleKey(uploadError, uploadResponse, context.currentMode) : void 0,
 		needsBackCapture: shouldCaptureBack(context),
@@ -149,8 +253,17 @@ function mapManualUploadState(snapshot) {
 	* keeps both slots visible once the front has been processed.
 	*/
 	const backUploaded = (childCtx?.backUploaded ?? false) || (childCtx?.skipBackFromServer ?? false);
-	const idTabCanContinue = (childCtx?.frontUploaded ?? false) && backUploaded;
+	/**
+	* Manual upload is client-authoritative for the back side: the slot must be
+	* shown or hidden before any upload round-trip, so there is no
+	* `skipBackIdCapture` to defer to yet. `config.onlyFront` is therefore read
+	* directly here — restoring V1 parity (ENG-50532). The camera path is the
+	* opposite: it forwards the flag and waits for the server's answer.
+	*/
+	const onlyFront = config.onlyFront === true;
+	const idTabCanContinue = (childCtx?.frontUploaded ?? false) && (onlyFront || backUploaded);
 	const canContinue = childCtx?.activeTab === "id" ? idTabCanContinue : childCtx?.passportUploaded ?? false;
+	const showBackSlot = !onlyFront;
 	return {
 		status: "manualUpload",
 		phase,
@@ -158,7 +271,7 @@ function mapManualUploadState(snapshot) {
 		activeTab: childCtx?.activeTab ?? "id",
 		showIdTab,
 		showPassportTab,
-		showBackSlot: true,
+		showBackSlot,
 		frontFileName: childCtx?.frontFile?.name,
 		backFileName: childCtx?.backFile?.name,
 		passportFileName: childCtx?.passportFile?.name,
@@ -229,20 +342,33 @@ function mapState(snapshot) {
 		status: "mandatoryConsent",
 		regulationType: context.uploadResponse?.regulationType ?? "Other"
 	};
-	if (snapshot.matches("frontFinished")) return { status: "frontFinished" };
-	if (snapshot.matches("backFinished")) return { status: "backFinished" };
+	if (snapshot.matches("frontFinished")) return {
+		status: "frontFinished",
+		previewImageUrl: context.flipPreview?.url,
+		orientation: context.flipPreview?.orientation,
+		mode: context.flipPreview?.mode ?? "id"
+	};
+	if (snapshot.matches("backFinished")) return {
+		status: "backFinished",
+		previewImageUrl: context.flipPreview?.url,
+		orientation: context.flipPreview?.orientation,
+		mode: context.flipPreview?.mode ?? "id"
+	};
 	if (snapshot.matches("processing")) return { status: "processing" };
 	if (snapshot.matches("expiredExhausted")) return { status: "expiredExhausted" };
 	if (snapshot.matches("expired")) {
 		const counter = context.expiredFromUpload ? context.expiredAttempts : context.processingExpiredAttempts;
-		const cap = context.expiredFromUpload ? MAX_EXPIRED_FIRST_SIDE_ATTEMPTS : context.config.captureAttempts;
+		const cap = context.expiredFromUpload ? 3 : context.config.captureAttempts;
 		return {
 			status: "expired",
 			attemptsRemaining: Math.max(0, cap - counter),
 			currentMode: context.currentMode
 		};
 	}
-	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		output: snapshot.output
+	};
 	if (snapshot.matches("error")) return {
 		status: "error",
 		error: context.error ?? "Unknown error"
@@ -270,9 +396,9 @@ function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished })
 		},
 		async nextStep() {
 			trackElementClicked?.("nextStep");
-			const snapshot$1 = actor.getSnapshot();
-			if (snapshot$1.matches("tutorial")) {
-				const { config, permissionResult } = snapshot$1.context;
+			const snapshot = actor.getSnapshot();
+			if (snapshot.matches("tutorial")) {
+				const { config, permissionResult } = snapshot.context;
 				await primeMotionFromUserGestureIfNeeded({
 					ds: config.ds,
 					cameraGranted: permissionResult === "granted"
@@ -280,6 +406,14 @@ function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished })
 			}
 			actor.send({ type: "NEXT_STEP" });
 		},
+		/**
+		* Advances out of `resultPreview`. Deliberately untracked: this fires from
+		* the UI's own dwell timer / animationend, not a user action, so it must not
+		* emit an `elementClicked`.
+		*/
+		completeResultPreview() {
+			actor.send({ type: "RESULT_PREVIEW_COMPLETE" });
+		},
 		requestPermission() {
 			trackElementClicked?.("requestPermission");
 			actor.send({ type: "REQUEST_PERMISSION" });
@@ -339,12 +473,22 @@ function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished })
 			trackElementClicked?.("cancelMandatoryConsent");
 			actor.send({ type: "CONSENT_CANCEL" });
 		},
+		/**
+		* Updates the detection area used for WASM geometry calculation.
+		* Call this when the UI detection area dimensions change (e.g., on resize or orientation change).
+		*/
 		updateDetectionArea(detectionArea) {
 			actor.send({
 				type: "UPDATE_DETECTION_AREA",
 				detectionArea
 			});
 		},
+		/**
+		* Manual upload: tab change (ID / Passport). Resets per-tab file selections.
+		* Note: there is intentionally no `switchToManualUpload` method — entry to
+		* the manual-upload flow is gated by config + Chooser to prevent a
+		* dev-console bypass of live camera capture.
+		*/
 		manualUploadChangeTab(tab) {
 			trackElementClicked?.(`manualUpload.tab.${tab}`);
 			actor.send({
@@ -436,8 +580,6 @@ function getCaptureLiveCueScreen(screens, detectionStatus) {
 		case "offline": return `${screens.capturePrefix}.livecue-dark`;
 		case "manualCapture": return `${screens.capturePrefix}.manual`;
 		case "capturing": return `${screens.capturePrefix}.takingphoto`;
-		case "detecting":
-		case "idle":
 		default: return `${screens.capturePrefix}.default`;
 	}
 }
@@ -454,10 +596,6 @@ function getCaptureErrorScreen(screens, errorCode) {
 		case "NO_MORE_TRIES": return `${screens.errorPrefix}.failedExhausted`;
 		case "NO_TOKEN":
 		case "SERVER_ERROR": return `${screens.errorPrefix}.nointernet`;
-		case "UPLOAD_ERROR":
-		case "UNEXPECTED_ERROR":
-		case "PERMISSION_DENIED":
-		case "USER_CANCELLED":
 		default: return `${screens.errorPrefix}.failed`;
 	}
 }
@@ -480,6 +618,7 @@ function getCaptureSubstateScreen(snapshot, screens) {
 		case "capturing": return `${screens.capturePrefix}.takingphoto`;
 		case "capturingManual": return `${screens.capturePrefix}.manual`;
 		case "uploading":
+		case "uploadCompleted":
 		case "validatingUpload": return `${screens.analyzingPrefix}.uploading`;
 		case "uploadError": return getCaptureErrorScreen(screens, context.uploadError);
 		case "success": return getSuccessScreen(snapshot, screens);
@@ -504,8 +643,6 @@ function getPermissionScreen(value) {
 		case "denied": return "idCapture.permissions.quit";
 		case "learnMore": return "idCapture.commonissues.default";
 		case "motionOnly": return "idCapture.permissions.motionOnly";
-		case "idle":
-		case "waitingForUser":
 		default: return "idCapture.permissions.default";
 	}
 }
@@ -651,17 +788,20 @@ function createIdCaptureManagerFromActor(actor, visibilityObserver = new Browser
 		})
 	});
 }
-
 //#endregion
 //#region src/modules/id/idCaptureActor.ts
 function createIdCaptureActor(options) {
 	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
+	const treatment = resolveCaptureResultPreviewTreatment(options.config);
 	return createActor(idCaptureMachine, { input: {
-		config: options.config,
-		dependencies
+		config: {
+			...options.config,
+			thresholds: resolveIdCaptureThresholds(options.config, treatment?.framesAggregationInterval)
+		},
+		dependencies,
+		captureFeedbackMode: treatment?.mode ?? "countdown"
 	} }).start();
 }
-
 //#endregion
 //#region src/modules/id/idCaptureManager.ts
 /**
@@ -676,6 +816,5 @@ function createIdCaptureActor(options) {
 function createIdCaptureManager(options) {
 	return createIdCaptureManagerFromActor(createIdCaptureActor(options));
 }
-
 //#endregion
-export { createIdCaptureActor as n, createIdCaptureManagerFromActor as r, createIdCaptureManager as t };
+export { createIdCaptureActor as n, createIdCaptureManagerFromActor as r, createIdCaptureManager as t };