@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.2

package/dist/{browserSimulation-B1dWiXp7.esm.js → browserSimulation-CGjpdNA1.esm.js}

@@ -1,5 +1,5 @@
-import { r as isIOS } from "./platform-SKvEfCBh.esm.js";
-import { t as getUserAgent } from "./getBrowser-C8DP7oTB.esm.js";
+import { r as isIOS } from "./platform-BfoqeM61.esm.js";
+import { t as getUserAgent } from "./getBrowser-Dv8LZyHE.esm.js";
 
 //#region ../../node_modules/.pnpm/ua-parser-js@2.0.9/node_modules/ua-parser-js/src/main/ua-parser.mjs
 var LIBVERSION = "2.0.9", UA_MAX_LENGTH = 500, USER_AGENT = "user-agent", EMPTY = "", UNKNOWN = "?", TYPEOF = {

package/dist/camera.d.ts

@@ -1,4 +1,4 @@
-import { n as PermissionStatus, t as PermissionResult } from "./types-ya0LN_MX.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-F0IXbaCB.js";
 
 //#region src/internal/permissions/permissionServices.d.ts
 type RequestPermissionOptions = {

package/dist/camera.esm.js

@@ -1,6 +1,6 @@
-import "./WasmUtilProvider-BKWm8rSA.esm.js";
-import "./MotionSensorProvider-Bx7Mpzt0.esm.js";
-import { i as requestPermission, t as checkPermission } from "./permissionServices-Doec4X5L.esm.js";
-import "./camera-DJWm3V4g.esm.js";
+import "./WasmUtilProvider-CIu373BZ.esm.js";
+import "./MotionSensorProvider-C9fPAJdS.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-CPDboRoE.esm.js";
+import "./camera-x4LjGTjZ.esm.js";
 
 export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/certificate-issuance.d.ts

@@ -0,0 +1,311 @@
+import { t as Manager } from "./Manager-B2OEDYqf.js";
+import "./Actor-fIPLXfoi.js";
+import * as xstate0 from "xstate";
+
+//#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: xstate0.StateMachine<CertificateIssuanceContext, {
+  type: "LOAD";
+} | {
+  type: "PASSWORD_CHANGED";
+  password: string;
+} | {
+  type: "SUBMIT_PASSWORD";
+} | {
+  type: "DOWNLOADED";
+} | {
+  type: "DOWNLOAD_FAILED";
+} | {
+  type: "FINISH";
+}, {
+  [x: string]: xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<IssueCertificateResponse, {
+    password: string;
+  }, xstate0.EventObject>> | undefined;
+}, {
+  src: "issueCertificate";
+  logic: xstate0.PromiseActorLogic<IssueCertificateResponse, {
+    password: string;
+  }, xstate0.EventObject>;
+  id: string | undefined;
+}, xstate0.Values<{
+  setPassword: {
+    type: "setPassword";
+    params: xstate0.NonReducibleUnknown;
+  };
+  setBlob: {
+    type: "setBlob";
+    params: xstate0.NonReducibleUnknown;
+  };
+}>, {
+  type: "isPasswordValid";
+  params: unknown;
+}, never, "error" | "idle" | "processing" | "success" | "finished" | "password" | "downloaded", string, CertificateIssuanceInput, xstate0.NonReducibleUnknown, xstate0.EventObject, xstate0.MetaObject, {
+  readonly id: "certificateIssuance";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "issueCertificate">(logic: TSrc, ...[options]: {
+        src: "issueCertificate";
+        logic: xstate0.PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, xstate0.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "issueCertificate";
+        logic: xstate0.PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, xstate0.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate0.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate0.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate0.RequiredActorOptions<T>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredActorOptions<T>>> : never : never : never): xstate0.ActorRefFromLogic<xstate0.GetConcreteByKey<{
+        src: "issueCertificate";
+        logic: xstate0.PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, xstate0.EventObject>;
+        id: string | undefined;
+      }, "src", TSrc>["logic"]>;
+      <TLogic extends xstate0.AnyActorLogic>(src: TLogic, ...[options]: xstate0.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate0.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate0.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredLogicInput<TLogic>>>): xstate0.ActorRefFromLogic<TLogic>;
+    };
+    input: CertificateIssuanceInput;
+    self: xstate0.ActorRef<xstate0.MachineSnapshot<CertificateIssuanceContext, {
+      type: "LOAD";
+    } | {
+      type: "PASSWORD_CHANGED";
+      password: string;
+    } | {
+      type: "SUBMIT_PASSWORD";
+    } | {
+      type: "DOWNLOADED";
+    } | {
+      type: "DOWNLOAD_FAILED";
+    } | {
+      type: "FINISH";
+    }, Record<string, xstate0.AnyActorRef | undefined>, xstate0.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "PASSWORD_CHANGED";
+      password: string;
+    } | {
+      type: "SUBMIT_PASSWORD";
+    } | {
+      type: "DOWNLOADED";
+    } | {
+      type: "DOWNLOAD_FAILED";
+    } | {
+      type: "FINISH";
+    }, xstate0.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: xstate0.ActorRef<xstate0.MachineSnapshot<CertificateIssuanceContext, {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          }, Record<string, xstate0.AnyActorRef>, xstate0.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          }, xstate0.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
+//#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 };

package/dist/certificate-issuance.esm.js

@@ -0,0 +1,73 @@
+import "./api-DUZwyz0o.esm.js";
+import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-DN-u67gb.esm.js";
+import "./endpoints-BM2_j_IE.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-Dkm1jy5u.esm.js";
+import "./urlUtils-8RNHyW3x.esm.js";
+import "./externalFetch-crimxkN9.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-CLNXtXaC.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 };

package/dist/certificateIssuanceStateMachine-CLNXtXaC.esm.js

@@ -0,0 +1,127 @@
+import { n as getApi, r as getToken } from "./api-DUZwyz0o.esm.js";
+import { t as endpoints } from "./endpoints-BM2_j_IE.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Dkm1jy5u.esm.js";
+import { t as externalFetch } from "./externalFetch-crimxkN9.esm.js";
+
+//#region src/modules/certificate-issuance/certificateIssuanceServices.ts
+function buildIssueCertificateUrl(baseURL) {
+	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${endpoints.certificateIssuanceIssue}`;
+}
+/**
+* Issues a digital certificate and returns it as a Blob.
+*/
+async function issueCertificate(params, signal) {
+	const { baseURL, headers: defaultHeaders } = getApi().defaults;
+	const token = getToken();
+	return { blob: await (await externalFetch({
+		method: "POST",
+		url: buildIssueCertificateUrl(baseURL),
+		headers: {
+			...defaultHeaders,
+			Accept: "application/octet-stream",
+			...token ? { "X-Incode-Hardware-Id": token } : {}
+		},
+		body: JSON.stringify({ password: params.password }),
+		signal
+	})).blob() };
+}
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceConstants.ts
+const MIN_PASSWORD_LENGTH = 8;
+const PASSWORD_VALIDATION_KEYS = [
+	"length",
+	"uppercase",
+	"lowercase",
+	"number"
+];
+const REQUIREMENT_I18N_KEYS = {
+	length: "certificateIssuance.password.length",
+	uppercase: "certificateIssuance.password.uppercase",
+	lowercase: "certificateIssuance.password.lowercase",
+	number: "certificateIssuance.password.number"
+};
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceUtils.ts
+function emptyPasswordValidations() {
+	return {
+		length: false,
+		uppercase: false,
+		lowercase: false,
+		number: false
+	};
+}
+function validatePassword(value) {
+	return {
+		length: value.length >= MIN_PASSWORD_LENGTH,
+		uppercase: /[A-Z]/.test(value),
+		lowercase: /[a-z]/.test(value),
+		number: /[0-9]/.test(value)
+	};
+}
+function isPasswordValid(validations) {
+	return PASSWORD_VALIDATION_KEYS.every((key) => validations[key]);
+}
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceStateMachine.ts
+const certificateIssuanceMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { issueCertificate: fromPromise(async ({ input, signal }) => issueCertificate({ password: input.password }, signal)) },
+	actions: {
+		setPassword: assign(({ event }) => {
+			const e = event;
+			return {
+				password: e.password,
+				passwordValidations: validatePassword(e.password)
+			};
+		}),
+		setBlob: assign(({ event }) => ({ certificateBlob: "output" in event ? event.output.blob : void 0 }))
+	},
+	guards: { isPasswordValid: ({ context }) => isPasswordValid(context.passwordValidations) }
+}).createMachine({
+	id: "certificateIssuance",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		password: "",
+		passwordValidations: emptyPasswordValidations(),
+		certificateBlob: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "password" } } },
+		password: { on: {
+			PASSWORD_CHANGED: { actions: "setPassword" },
+			SUBMIT_PASSWORD: {
+				target: "processing",
+				guard: "isPasswordValid"
+			}
+		} },
+		processing: { invoke: {
+			id: "issueCertificate",
+			src: "issueCertificate",
+			input: ({ context }) => ({ password: context.password }),
+			onDone: {
+				target: "success",
+				actions: "setBlob"
+			},
+			onError: { target: "error" }
+		} },
+		success: { on: {
+			DOWNLOADED: { target: "downloaded" },
+			DOWNLOAD_FAILED: { target: "error" },
+			FINISH: { target: "finished" }
+		} },
+		downloaded: { on: { FINISH: { target: "finished" } } },
+		error: { after: { 3e3: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { MIN_PASSWORD_LENGTH as a, validatePassword as i, emptyPasswordValidations as n, PASSWORD_VALIDATION_KEYS as o, isPasswordValid as r, REQUIREMENT_I18N_KEYS as s, certificateIssuanceMachine as t };

package/dist/consent.d.ts

@@ -1,4 +1,4 @@
-import "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-Cg5Sk2tv.js";
+import "./Manager-B2OEDYqf.js";
+import "./Actor-fIPLXfoi.js";
+import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-BqUGU_YD.js";
 export { type ConsentActor, type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/consent.esm.js

@@ -1,8 +1,8 @@
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import { t as consentMachine } from "./consentStateMachine-BG3yL8aC.esm.js";
-import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BYo9Nu1r.esm.js";
+import "./api-DUZwyz0o.esm.js";
+import "./events-DN-u67gb.esm.js";
+import "./endpoints-BM2_j_IE.esm.js";
+import "./xstate.esm-Dkm1jy5u.esm.js";
+import { t as consentMachine } from "./consentStateMachine-DRsFFSHE.esm.js";
+import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-psDCeJ0E.esm.js";
 
 export { consentMachine, createConsentManager, createConsentManagerFromActor };