@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/{backCameraStream-CUeYm5eu.esm.js → backCameraStream-BOtyQowf.esm.js}

@@ -1,7 +1,7 @@
-import { i as isIOS, o as isIPhone14OrHigher, r as isDesktop, s as isSafari, t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
-import { a as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-_2sXMXiF.esm.js";
+import { a as isIOS, c as isIPhone14OrHigher, d as isSafari, i as isDesktop, t as isAndroid } from "./platform-DkcRc9JV.esm.js";
+import { i as requestCameraAccess, n as enumerateVideoDevices, o as stopCameraStream, t as applyTrackConstraints } from "./camera-sIa9ceW2.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
-import { t as getBrowser } from "./getBrowser-DNrQeL4T.esm.js";
+import { t as getBrowser } from "./getBrowser-Cbe1C4Tn.esm.js";
 //#region src/internal/camera/backCameraStream.ts
 const BACK_CAMERA_KEYWORDS = [
 	"rear",
@@ -46,6 +46,10 @@ function isBackCameraLabel(label) {
 	const lowercaseLabel = label.toLowerCase();
 	return BACK_CAMERA_KEYWORDS.some((keyword) => lowercaseLabel.includes(keyword));
 }
+function isBackFacingTrack(track) {
+	const settings = track.getSettings();
+	return isBackCameraLabel(track.label) || settings.facingMode === "environment";
+}
 function classifyCamera(device, index, totalDevices) {
 	let cameraType;
 	if (device.label === "") cameraType = totalDevices === 1 || index + 1 <= totalDevices / 2 ? "front" : "back";
@@ -97,7 +101,7 @@ function selectMainCameraFromStream(track, cameras) {
 	const settings = track.getSettings();
 	const activeCamera = cameras.find((c) => c.deviceId === settings.deviceId || c.label !== "" && c.label === track.label);
 	if (!activeCamera) return void 0;
-	if ((settings.facingMode === "environment" || isBackCameraLabel(track.label)) && cameras.length > 1) {
+	if (isBackFacingTrack(track) && cameras.length > 1) {
 		cameras.forEach((camera) => {
 			if (camera.deviceId === activeCamera.deviceId) camera.cameraType = "back";
 			else if (!isBackCameraLabel(camera.label)) camera.cameraType = "front";
@@ -209,8 +213,11 @@ async function getAndroidBackCameraStream(fallbackLevel = 0) {
 		const mainCamera = selectMainCameraFromStream(track, await getCameras());
 		stopCameraStream(initialStream);
 		if (!mainCamera) throw new Error("Could not identify main camera");
+		const acquisitionConstraints = getAndroidFinalConstraints(mainCamera, fallbackLevel);
+		const finalStream = await requestCameraAccess({ video: acquisitionConstraints });
 		return {
-			stream: await requestCameraAccess({ video: getAndroidFinalConstraints(mainCamera, fallbackLevel) }),
+			stream: finalStream,
+			constraints: await applyAutofocusHint(finalStream, acquisitionConstraints),
 			fallbackLevel
 		};
 	} catch (error) {
@@ -228,16 +235,52 @@ async function getAndroidBackCameraStream(fallbackLevel = 0) {
 	}
 }
 async function getFirefoxAndroidBackCameraStream() {
+	const requestConstraints = getDesktopConstraints({ facingMode: "environment" });
+	const acquisitionConstraints = getVideoTrackConstraints(requestConstraints);
+	const stream = await requestCameraAccess(requestConstraints);
 	return {
-		stream: await requestCameraAccess(getDesktopConstraints({ facingMode: "environment" })),
+		stream,
+		constraints: await applyAutofocusHint(stream, acquisitionConstraints),
 		fallbackLevel: 0
 	};
 }
-async function applyFocusHint(stream) {
+/**
+* Preserve SDK 1's iOS focus-distance hint and request the browser's continuous
+* autofocus mode on any selected back-camera track that advertises it.
+*
+* This is deliberately capability-gated and best-effort. A fixed focus
+* distance on Android can blur a close document, while an unsupported advanced
+* constraint must never make camera acquisition fail.
+*/
+async function applyAutofocusHint(stream, acquisitionConstraints, includeIOSFocusDistance = false) {
 	const videoTrack = stream.getVideoTracks()[0];
+	if (!videoTrack) return acquisitionConstraints;
+	let focusMode;
 	try {
-		await applyTrackConstraints(videoTrack, { advanced: [{ focusDistance: 1 }] });
+		const advertisedModes = (videoTrack.getCapabilities?.())?.focusMode;
+		const supportedModes = Array.isArray(advertisedModes) ? advertisedModes : advertisedModes ? [advertisedModes] : [];
+		focusMode = supportedModes.includes("continuous") ? "continuous" : supportedModes.includes("auto") ? "auto" : void 0;
 	} catch {}
+	if (!focusMode && !includeIOSFocusDistance) return acquisitionConstraints;
+	const focusConstraints = {
+		...focusMode ? { focusMode } : {},
+		...includeIOSFocusDistance ? { focusDistance: 1 } : {}
+	};
+	const constraints = {
+		...acquisitionConstraints,
+		advanced: [...acquisitionConstraints.advanced ?? [], focusConstraints]
+	};
+	try {
+		await applyTrackConstraints(videoTrack, constraints);
+		return constraints;
+	} catch {
+		try {
+			await applyTrackConstraints(videoTrack, { advanced: [focusConstraints] });
+			return constraints;
+		} catch {
+			return acquisitionConstraints;
+		}
+	}
 }
 function getIOSConstraints() {
 	return {
@@ -250,9 +293,13 @@ function getIOSConstraints() {
 	};
 }
 async function getIOSCameraStream() {
-	const stream = await requestCameraAccess(getIOSConstraints());
-	await applyFocusHint(stream);
-	return stream;
+	const requestConstraints = getIOSConstraints();
+	const acquisitionConstraints = getVideoTrackConstraints(requestConstraints);
+	const stream = await requestCameraAccess(requestConstraints);
+	return {
+		stream,
+		constraints: await applyAutofocusHint(stream, acquisitionConstraints, true)
+	};
 }
 function getDesktopVideoConstraints(level) {
 	switch (level) {
@@ -331,17 +378,26 @@ function getDesktopConstraints(options, level = 0) {
 		}
 	};
 }
-async function getDesktopCameraStream(options, fallbackLevel = 0) {
+function getVideoTrackConstraints(constraints) {
+	return constraints.video && typeof constraints.video !== "boolean" ? constraints.video : {};
+}
+async function getDesktopCameraStreamResult(options, fallbackLevel = 0) {
 	if (fallbackLevel > 5) throw new Error("Failed to get desktop camera after all fallback attempts");
 	const constraints = getDesktopConstraints(options, fallbackLevel);
 	try {
-		return await requestCameraAccess(constraints);
+		return {
+			stream: await requestCameraAccess(constraints),
+			constraints: getVideoTrackConstraints(constraints)
+		};
 	} catch (error) {
 		const nextLevel = fallbackLevel + 1;
 		if (nextLevel > 5) throw error;
-		return getDesktopCameraStream(options, nextLevel);
+		return getDesktopCameraStreamResult(options, nextLevel);
 	}
 }
+async function getDesktopCameraStream(options, fallbackLevel = 0) {
+	return (await getDesktopCameraStreamResult(options, fallbackLevel)).stream;
+}
 /**
 * Pick the best back-facing device from a list already filtered by label.
 * Prefers the highest megapixel count when labels advertise it, else the first.
@@ -377,17 +433,17 @@ function selectBestBackDevice(devices) {
 * An explicit deviceId from the caller is always trusted as-is.
 */
 async function getDesktopBackCameraStream(deviceId) {
-	if (deviceId) return getDesktopCameraStream({ deviceId });
-	const original = await getDesktopCameraStream({ facingMode: "environment" });
-	const track = original.getVideoTracks()[0];
+	if (deviceId) return getDesktopCameraStreamResult({ deviceId });
+	const original = await getDesktopCameraStreamResult({ facingMode: "environment" });
+	const track = original.stream.getVideoTracks()[0];
 	if (track && isBackCameraLabel(track.label)) return original;
 	const backDevices = (await enumerateVideoDevices()).filter((d) => isBackCameraLabel(d.label));
 	if (backDevices.length === 0) return original;
 	const target = selectBestBackDevice(backDevices);
 	if (track && track.getSettings().deviceId === target.deviceId) return original;
 	try {
-		const corrected = await getDesktopCameraStream({ deviceId: target.deviceId });
-		stopCameraStream(original);
+		const corrected = await getDesktopCameraStreamResult({ deviceId: target.deviceId });
+		stopCameraStream(original.stream);
 		return corrected;
 	} catch {
 		return original;
@@ -431,12 +487,17 @@ async function ensureFrontCameraStream(open) {
 	}
 }
 async function getBackCameraStream(deviceId) {
-	if (isIOS()) return { stream: await getIOSCameraStream() };
+	if (isIOS()) return getIOSCameraStream();
 	if (isAndroid()) {
 		if (getBrowser() === "firefox") return getFirefoxAndroidBackCameraStream();
 		return getAndroidBackCameraStream(0);
 	}
-	return { stream: await getDesktopBackCameraStream(deviceId) };
+	const acquired = await getDesktopBackCameraStream(deviceId);
+	const constraints = await applyAutofocusHint(acquired.stream, acquired.constraints);
+	return {
+		stream: acquired.stream,
+		constraints
+	};
 }
 //#endregion
-export { hasBackCamera as i, getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };
+export { isBackFacingTrack as a, hasBackCamera as i, getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };

package/dist/{camera-_2sXMXiF.esm.js → camera-sIa9ceW2.esm.js}

@@ -126,6 +126,24 @@ async function requestCameraWithFallback(baseConstraints, fallbacks = DEFAULT_RE
 	}
 	throw new Error("All camera resolution fallbacks failed");
 }
+/**
+* Preserve the constraints used for an acquired camera while pinning future
+* acquisitions to the device the browser actually selected.
+*
+* Protected WASM PRC/POC may reacquire the stream. Advisory constraints such
+* as `facingMode` are not enough on devices with multiple matching cameras,
+* so the selected device must be replayed as an exact constraint.
+*/
+function getCameraReacquisitionConstraints(track, acquisitionConstraints) {
+	if (!track) return acquisitionConstraints;
+	const constraints = acquisitionConstraints ?? track.getConstraints();
+	const selectedDeviceId = track.getSettings().deviceId;
+	if (!selectedDeviceId) return constraints;
+	return {
+		...constraints,
+		deviceId: { exact: selectedDeviceId }
+	};
+}
 function stopCameraStream(stream) {
 	for (const track of stream.getTracks()) track.stop();
 }
@@ -137,4 +155,4 @@ async function applyTrackConstraints(track, constraints) {
 	await track.applyConstraints(constraints);
 }
 //#endregion
-export { stopCameraStream as a, requestCameraWithFallback as i, enumerateVideoDevices as n, clearCameraGrantedInDocument as o, requestCameraAccess as r, isCameraGrantedInDocument as s, applyTrackConstraints as t };
+export { requestCameraWithFallback as a, isCameraGrantedInDocument as c, requestCameraAccess as i, enumerateVideoDevices as n, stopCameraStream as o, getCameraReacquisitionConstraints as r, clearCameraGrantedInDocument as s, applyTrackConstraints as t };

package/dist/camera.esm.js

@@ -1,2 +1,2 @@
-import { i as requestPermission, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-Bj_fyWtv.esm.js";
 export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/{canvas-E1zGkel4.esm.js → canvas-BxFzWTt-.esm.js}

@@ -170,6 +170,25 @@ var IncodeCanvas = class IncodeCanvas {
 		if (base64) this.blobData = IncodeCanvas.base64ToBlob(base64);
 	}
 	/**
+	* Creates a JPEG Blob without synchronously encoding the canvas as base64.
+	* Returns `null` when the canvas is invalid, encoding is unavailable, or the
+	* browser cannot produce a Blob.
+	*/
+	async updateBlobAsync(jpegQuality = 1) {
+		if (!this.checkCanvas() || typeof this.canvas.toBlob !== "function") return null;
+		const blob = await new Promise((resolve) => {
+			this.canvas.toBlob(resolve, "image/jpeg", jpegQuality);
+		});
+		if (!blob) return null;
+		if (this.blobData?.url) URL.revokeObjectURL(this.blobData.url);
+		const blobData = {
+			blob,
+			url: URL.createObjectURL(blob)
+		};
+		this.blobData = blobData;
+		return blobData;
+	}
+	/**
 	* Converts a base64 string to a Blob and creates a URL for it.
 	*/
 	static base64ToBlob(base64) {

package/dist/certificate-issuance.d.ts

@@ -1,307 +1,7 @@
-import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
-import "./StateMachine-EDpYWy0i.js";
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-import "./Actor-iTq7YY48.js";
-//#region src/modules/certificate-issuance/certificateIssuanceConstants.d.ts
-declare const MIN_PASSWORD_LENGTH = 8;
-declare const PASSWORD_VALIDATION_KEYS: readonly ["length", "uppercase", "lowercase", "number"];
-declare const REQUIREMENT_I18N_KEYS: Record<PasswordValidationKey, string>;
-//#endregion
-//#region src/modules/certificate-issuance/types.d.ts
-type CertificateIssuanceType = 'ONE_TIME' | 'SHORT_TERM' | 'LONG_TERM';
-/**
- * Configuration for the certificate issuance module.
- */
-type CertificateIssuanceConfig = {
-  /** Issuance region (from flow `moduleConfiguration`) */
-  region: string;
-  /** Certificate validity period */
-  type: CertificateIssuanceType;
-};
-type IssueCertificateResponse = {
-  blob: Blob;
-};
-type PasswordValidations = {
-  length: boolean;
-  uppercase: boolean;
-  lowercase: boolean;
-  number: boolean;
-};
-type PasswordValidationKey = (typeof PASSWORD_VALIDATION_KEYS)[number];
-//#endregion
-//#region src/modules/certificate-issuance/certificateIssuanceStateMachine.d.ts
-type CertificateIssuanceContext = {
-  config: CertificateIssuanceConfig;
-  password: string;
-  passwordValidations: PasswordValidations;
-  certificateBlob: Blob | undefined;
-};
-type CertificateIssuanceInput = {
-  config: CertificateIssuanceConfig;
-};
-declare const certificateIssuanceMachine: StateMachine<CertificateIssuanceContext, {
-  type: "LOAD";
-} | {
-  type: "PASSWORD_CHANGED";
-  password: string;
-} | {
-  type: "SUBMIT_PASSWORD";
-} | {
-  type: "DOWNLOADED";
-} | {
-  type: "DOWNLOAD_FAILED";
-} | {
-  type: "FINISH";
-}, {
-  [x: string]: ActorRefFromLogic<PromiseActorLogic<IssueCertificateResponse, {
-    password: string;
-  }, EventObject>> | undefined;
-}, {
-  src: "issueCertificate";
-  logic: PromiseActorLogic<IssueCertificateResponse, {
-    password: string;
-  }, EventObject>;
-  id: string | undefined;
-}, Values<{
-  setPassword: {
-    type: "setPassword";
-    params: NonReducibleUnknown;
-  };
-  setBlob: {
-    type: "setBlob";
-    params: NonReducibleUnknown;
-  };
-}>, {
-  type: "isPasswordValid";
-  params: unknown;
-}, never, "error" | "idle" | "processing" | "success" | "finished" | "password" | "downloaded", string, CertificateIssuanceInput, NonReducibleUnknown, EventObject, MetaObject, {
-  readonly id: "certificateIssuance";
-  readonly initial: "idle";
-  readonly context: ({ input }: {
-    spawn: {
-      <TSrc extends "issueCertificate">(logic: TSrc, ...[options]: {
-        src: "issueCertificate";
-        logic: PromiseActorLogic<IssueCertificateResponse, {
-          password: string;
-        }, EventObject>;
-        id: string | undefined;
-      } extends (infer T) ? T extends {
-        src: "issueCertificate";
-        logic: PromiseActorLogic<IssueCertificateResponse, {
-          password: string;
-        }, EventObject>;
-        id: string | undefined;
-      } ? T extends {
-        src: TSrc;
-      } ? ConditionalRequired<[options?: ({
-        id?: T["id"] | undefined;
-        systemId?: string;
-        input?: InputFrom<T["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never): ActorRefFromLogic<GetConcreteByKey<{
-        src: "issueCertificate";
-        logic: PromiseActorLogic<IssueCertificateResponse, {
-          password: string;
-        }, EventObject>;
-        id: string | undefined;
-      }, "src", TSrc>["logic"]>;
-      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
-        id?: never;
-        systemId?: string;
-        input?: InputFrom<TLogic> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
-    };
-    input: CertificateIssuanceInput;
-    self: ActorRef<MachineSnapshot<CertificateIssuanceContext, {
-      type: "LOAD";
-    } | {
-      type: "PASSWORD_CHANGED";
-      password: string;
-    } | {
-      type: "SUBMIT_PASSWORD";
-    } | {
-      type: "DOWNLOADED";
-    } | {
-      type: "DOWNLOAD_FAILED";
-    } | {
-      type: "FINISH";
-    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
-      type: "LOAD";
-    } | {
-      type: "PASSWORD_CHANGED";
-      password: string;
-    } | {
-      type: "SUBMIT_PASSWORD";
-    } | {
-      type: "DOWNLOADED";
-    } | {
-      type: "DOWNLOAD_FAILED";
-    } | {
-      type: "FINISH";
-    }, AnyEventObject>;
-  }) => {
-    config: CertificateIssuanceConfig;
-    password: string;
-    passwordValidations: PasswordValidations;
-    certificateBlob: undefined;
-  };
-  readonly states: {
-    readonly idle: {
-      readonly on: {
-        readonly LOAD: {
-          readonly target: "password";
-        };
-      };
-    };
-    readonly password: {
-      readonly on: {
-        readonly PASSWORD_CHANGED: {
-          readonly actions: "setPassword";
-        };
-        readonly SUBMIT_PASSWORD: {
-          readonly target: "processing";
-          readonly guard: "isPasswordValid";
-        };
-      };
-    };
-    readonly processing: {
-      readonly invoke: {
-        readonly id: "issueCertificate";
-        readonly src: "issueCertificate";
-        readonly input: ({ context }: {
-          context: CertificateIssuanceContext;
-          event: {
-            type: "LOAD";
-          } | {
-            type: "PASSWORD_CHANGED";
-            password: string;
-          } | {
-            type: "SUBMIT_PASSWORD";
-          } | {
-            type: "DOWNLOADED";
-          } | {
-            type: "DOWNLOAD_FAILED";
-          } | {
-            type: "FINISH";
-          };
-          self: ActorRef<MachineSnapshot<CertificateIssuanceContext, {
-            type: "LOAD";
-          } | {
-            type: "PASSWORD_CHANGED";
-            password: string;
-          } | {
-            type: "SUBMIT_PASSWORD";
-          } | {
-            type: "DOWNLOADED";
-          } | {
-            type: "DOWNLOAD_FAILED";
-          } | {
-            type: "FINISH";
-          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
-            type: "LOAD";
-          } | {
-            type: "PASSWORD_CHANGED";
-            password: string;
-          } | {
-            type: "SUBMIT_PASSWORD";
-          } | {
-            type: "DOWNLOADED";
-          } | {
-            type: "DOWNLOAD_FAILED";
-          } | {
-            type: "FINISH";
-          }, AnyEventObject>;
-        }) => {
-          password: string;
-        };
-        readonly onDone: {
-          readonly target: "success";
-          readonly actions: "setBlob";
-        };
-        readonly onError: {
-          readonly target: "error";
-        };
-      };
-    };
-    readonly success: {
-      readonly on: {
-        readonly DOWNLOADED: {
-          readonly target: "downloaded";
-        };
-        readonly DOWNLOAD_FAILED: {
-          readonly target: "error";
-        };
-        readonly FINISH: {
-          readonly target: "finished";
-        };
-      };
-    };
-    readonly downloaded: {
-      readonly on: {
-        readonly FINISH: {
-          readonly target: "finished";
-        };
-      };
-    };
-    readonly error: {
-      readonly after: {
-        readonly 3000: {
-          readonly target: "finished";
-        };
-      };
-    };
-    readonly finished: {
-      readonly type: "final";
-    };
-  };
-}>;
-//#endregion
-//#region src/modules/certificate-issuance/certificateIssuanceActor.d.ts
-type CreateCertificateIssuanceActorOptions = {
-  config: CertificateIssuanceConfig;
-};
-//#endregion
-//#region src/modules/certificate-issuance/certificateIssuanceManager.d.ts
-type CertificateIssuanceIdleState = {
-  status: 'idle';
-};
-type CertificateIssuancePasswordState = {
-  status: 'password';
-  password: string;
-  passwordValidations: PasswordValidations;
-  canSubmit: boolean;
-};
-type CertificateIssuanceProcessingState = {
-  status: 'processing';
-};
-type CertificateIssuanceErrorState = {
-  status: 'error';
-};
-type CertificateIssuanceSuccessState = {
-  status: 'success';
-  blob: Blob;
-};
-type CertificateIssuanceDownloadedState = {
-  status: 'downloaded';
-};
-type CertificateIssuanceFinishedState = {
-  status: 'finished';
-};
-type CertificateIssuanceState = CertificateIssuanceIdleState | CertificateIssuancePasswordState | CertificateIssuanceProcessingState | CertificateIssuanceSuccessState | CertificateIssuanceDownloadedState | CertificateIssuanceErrorState | CertificateIssuanceFinishedState;
-declare function createCertificateIssuanceManager(options: CreateCertificateIssuanceActorOptions): Manager<CertificateIssuanceState> & {
-  load(): void;
-  setPassword(password: string): void;
-  submitPassword(): void;
-  markDownloaded(): void;
-  reportDownloadError(): void;
-  finish(): void;
-};
-type CertificateIssuanceManager = ReturnType<typeof createCertificateIssuanceManager>;
-//#endregion
+import { a as CertificateIssuanceActor, c as CertificateIssuanceType, d as PasswordValidations, f as MIN_PASSWORD_LENGTH, i as createCertificateIssuanceManagerFromActor, l as IssueCertificateResponse, m as REQUIREMENT_I18N_KEYS, n as CertificateIssuanceState, o as certificateIssuanceMachine, p as PASSWORD_VALIDATION_KEYS, r as createCertificateIssuanceManager, s as CertificateIssuanceConfig, t as CertificateIssuanceManager, u as PasswordValidationKey } from "./certificateIssuanceManager-DCgEidHz.js";
 //#region src/modules/certificate-issuance/certificateIssuanceUtils.d.ts
 declare function emptyPasswordValidations(): PasswordValidations;
 declare function validatePassword(value: string): PasswordValidations;
 declare function isPasswordValid(validations: PasswordValidations): boolean;
 //#endregion
-export { type CertificateIssuanceConfig, type CertificateIssuanceManager, type CertificateIssuanceState, type CertificateIssuanceType, type IssueCertificateResponse, MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, type PasswordValidationKey, type PasswordValidations, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, emptyPasswordValidations, isPasswordValid, validatePassword };
+export { type CertificateIssuanceActor, type CertificateIssuanceConfig, type CertificateIssuanceManager, type CertificateIssuanceState, type CertificateIssuanceType, type IssueCertificateResponse, MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, type PasswordValidationKey, type PasswordValidations, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, createCertificateIssuanceManagerFromActor, emptyPasswordValidations, isPasswordValid, validatePassword };

package/dist/certificate-issuance.esm.js

@@ -1,66 +1,3 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { a as MIN_PASSWORD_LENGTH, i as validatePassword, n as emptyPasswordValidations, o as PASSWORD_VALIDATION_KEYS, r as isPasswordValid, s as REQUIREMENT_I18N_KEYS, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-D_R92TYu.esm.js";
-//#region src/modules/certificate-issuance/certificateIssuanceActor.ts
-/**
-* Creates and starts a certificate issuance actor.
-*/
-function createCertificateIssuanceActor(options) {
-	return createActor(certificateIssuanceMachine, { input: { config: options.config } }).start();
-}
-//#endregion
-//#region src/modules/certificate-issuance/certificateIssuanceManager.ts
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("password")) return {
-		status: "password",
-		password: context.password,
-		passwordValidations: context.passwordValidations,
-		canSubmit: isPasswordValid(context.passwordValidations)
-	};
-	if (typedSnapshot.matches("processing")) return { status: "processing" };
-	if (typedSnapshot.matches("error")) return { status: "error" };
-	if (typedSnapshot.matches("success")) return {
-		status: "success",
-		blob: context.certificateBlob
-	};
-	if (typedSnapshot.matches("downloaded")) return { status: "downloaded" };
-	if (typedSnapshot.matches("finished")) return { status: "finished" };
-	return { status: "idle" };
-}
-function createApi({ actor }) {
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		setPassword(password) {
-			actor.send({
-				type: "PASSWORD_CHANGED",
-				password
-			});
-		},
-		submitPassword() {
-			actor.send({ type: "SUBMIT_PASSWORD" });
-		},
-		markDownloaded() {
-			actor.send({ type: "DOWNLOADED" });
-		},
-		reportDownloadError() {
-			actor.send({ type: "DOWNLOAD_FAILED" });
-		},
-		finish() {
-			actor.send({ type: "FINISH" });
-		}
-	};
-}
-function createCertificateIssuanceManager(options) {
-	return createManager({
-		actor: createCertificateIssuanceActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.certificateIssuance)
-	});
-}
-//#endregion
-export { MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, emptyPasswordValidations, isPasswordValid, validatePassword };
+import { a as MIN_PASSWORD_LENGTH, i as validatePassword, n as emptyPasswordValidations, o as PASSWORD_VALIDATION_KEYS, r as isPasswordValid, s as REQUIREMENT_I18N_KEYS, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-BBD5h8c4.esm.js";
+import { n as createCertificateIssuanceManagerFromActor, t as createCertificateIssuanceManager } from "./certificateIssuanceManager-Bfvkq7Cy.esm.js";
+export { MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, createCertificateIssuanceManagerFromActor, emptyPasswordValidations, isPasswordValid, validatePassword };