@incodetech/core 2.2.0 → 2.3.0-rc.1

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-CxqS_nD-.esm.js";
+import { n as createCertificateIssuanceManagerFromActor, t as createCertificateIssuanceManager } from "./certificateIssuanceManager-C3-CI0_s.esm.js";
+export { MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, createCertificateIssuanceManagerFromActor, emptyPasswordValidations, isPasswordValid, validatePassword };

package/dist/certificateIssuanceManager-C3-CI0_s.esm.js

@@ -0,0 +1,69 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
+import { r as isPasswordValid, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-CxqS_nD-.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 createCertificateIssuanceManagerFromActor(createCertificateIssuanceActor(options));
+}
+function createCertificateIssuanceManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.certificateIssuance)
+	});
+}
+//#endregion
+export { createCertificateIssuanceManagerFromActor as n, createCertificateIssuanceManager as t };