@incodetech/core 0.0.0-dev-20260414-db434be → 0.0.0-dev-20260415-432dcaa

package/dist/electronicSignatureManager-BqePYetY.esm.js

@@ -0,0 +1,432 @@
+import { t as api } from "./api-Dp5p_Y6w.esm.js";
+import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-DmzL4OZZ.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-CitJJ2CJ.esm.js";
+
+//#region ../infra/src/http/externalFetch.ts
+async function externalFetch(config) {
+	const res = await fetch(config.url, {
+		method: config.method,
+		headers: config.headers,
+		body: config.body,
+		signal: config.signal
+	});
+	if (!res.ok) throw new Error(`${config.method} ${config.url} failed: ${res.status} ${res.statusText}`);
+	return res;
+}
+
+//#endregion
+//#region src/internal/electronicSignature/electronicSignatureServices.ts
+async function fetchUnsignedDocuments(signal) {
+	const res = await api.get(endpoints.aesUnsignedDocuments, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.aesUnsignedDocuments} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+function getSignEndpoint(variant) {
+	return variant === "qe" ? endpoints.qesSignDocument : endpoints.aesSignDocument;
+}
+async function signDocument(documentRef, variant, signal) {
+	const endpoint = getSignEndpoint(variant);
+	const res = await api.post(endpoint, {
+		documentRef,
+		userConsented: true
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function generateUploadUrl(signal) {
+	const res = await api.post(endpoints.aesGenerateUploadUrl, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.aesGenerateUploadUrl} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+/**
+* Uploads a PDF file to a presigned S3 URL.
+* Uses externalFetch (infra) to avoid SDK default headers (api-version, Accept, etc.)
+* that would cause S3 signature mismatch on the presigned URL.
+*/
+async function uploadDocumentFile(presignedUrl, data, signal) {
+	await externalFetch({
+		method: "PUT",
+		url: presignedUrl,
+		headers: { "Content-Type": "application/pdf" },
+		body: data,
+		signal
+	});
+}
+
+//#endregion
+//#region src/internal/electronicSignature/electronicSignatureActors.ts
+const fetchUnsignedDocsActor = fromPromise(async ({ signal }) => fetchUnsignedDocuments(signal));
+const signDocumentsActor = fromPromise(async ({ input, signal }) => {
+	return (await Promise.all(input.documents.map((doc) => signDocument(doc.documentRef, input.variant, signal)))).map((r) => ({ signedDocumentUrl: r.signedDocumentUrl }));
+});
+const uploadDocumentActor = fromPromise(async ({ input, signal }) => {
+	const fileData = input.getFileData();
+	if (!fileData) throw new Error("No file data available for upload");
+	const { preSignedUrl } = await generateUploadUrl(signal);
+	await uploadDocumentFile(preSignedUrl, fileData, signal);
+});
+
+//#endregion
+//#region src/internal/electronicSignature/types.ts
+const AE_CONSENT_KEYS = [
+	"terms",
+	"signElectronically",
+	"signDisplayed"
+];
+const QE_CONSENT_KEYS = [
+	"issuance",
+	"qesAcknowledgement",
+	"qscdConfirmation",
+	"termsAgreement",
+	"documentsReviewed"
+];
+function getConsentKeys(variant) {
+	return variant === "qe" ? QE_CONSENT_KEYS : AE_CONSENT_KEYS;
+}
+function getDefaultConsentChecks(variant) {
+	const keys = getConsentKeys(variant);
+	return Object.fromEntries(keys.map((k) => [k, false]));
+}
+function areAllConsented(checks) {
+	return Object.values(checks).every(Boolean);
+}
+
+//#endregion
+//#region src/internal/electronicSignature/electronicSignatureStateMachine.ts
+const electronicSignatureMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchUnsignedDocs: fetchUnsignedDocsActor,
+		signDocuments: signDocumentsActor,
+		uploadDocument: uploadDocumentActor
+	},
+	actions: {
+		setDocuments: assign(({ event }) => {
+			const { output } = event;
+			return { documents: output.documents ?? [] };
+		}),
+		setSignedDocuments: assign(({ event }) => {
+			const { output } = event;
+			return { signedDocuments: output };
+		}),
+		setFile: assign(({ event }) => {
+			const { fileName, fileSize, fileUrl } = event;
+			return {
+				fileName,
+				fileSize,
+				fileUrl
+			};
+		}),
+		updateConsent: assign(({ context, event }) => {
+			const { name, checked } = event;
+			return { consentChecks: {
+				...context.consentChecks,
+				[name]: checked
+			} };
+		}),
+		setViewingDocument: assign(({ event }) => ({ viewingDocumentUrl: event.url })),
+		clearViewingDocument: assign({ viewingDocumentUrl: () => null })
+	},
+	guards: {
+		errorFromUpload: ({ context }) => context.errorSource === "upload",
+		errorFromSigning: ({ context }) => context.errorSource === "signing",
+		shouldUpload: ({ context }) => context.config.uploadDocument === true,
+		shouldDownload: ({ context }) => context.config.downloadDocument === true,
+		allConsented: ({ context }) => areAllConsented(context.consentChecks),
+		hasDocuments: ({ event }) => {
+			const { output } = event;
+			return (output.documents?.length ?? 0) > 0;
+		},
+		allSigned: ({ event }) => {
+			const { output } = event;
+			return output.every((d) => !!d.signedDocumentUrl);
+		},
+		allSignedAndDownload: ({ context, event }) => {
+			const { output } = event;
+			return output.every((d) => !!d.signedDocumentUrl) && context.config.downloadDocument === true;
+		}
+	}
+}).createMachine({
+	id: "electronicSignature",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		getFileData: input.getFileData,
+		documents: [],
+		signedDocuments: [],
+		fileName: null,
+		fileSize: null,
+		fileUrl: null,
+		consentChecks: getDefaultConsentChecks(input.config.variant ?? "ae"),
+		viewingDocumentUrl: null,
+		errorMessage: "",
+		errorSource: null
+	}),
+	states: {
+		idle: { on: { LOAD: [{
+			target: "uploading",
+			guard: "shouldUpload"
+		}, { target: "fetchingDocs" }] } },
+		uploading: { on: {
+			SELECT_FILE: {
+				target: "reviewing",
+				actions: "setFile"
+			},
+			CLOSE: { target: "closed" }
+		} },
+		reviewing: { on: {
+			REPLACE_FILE: {
+				target: "uploading",
+				actions: assign({
+					fileName: () => null,
+					fileSize: () => null,
+					fileUrl: () => null
+				})
+			},
+			CONFIRM_FILE: { target: "uploadingFile" },
+			CLOSE: { target: "closed" }
+		} },
+		uploadingFile: { invoke: {
+			id: "uploadDocument",
+			src: "uploadDocument",
+			input: ({ context }) => ({ getFileData: context.getFileData }),
+			onDone: { target: "fetchingDocs" },
+			onError: {
+				target: "error",
+				actions: assign(({ event }) => ({
+					errorMessage: String(event.error ?? "aes.error"),
+					errorSource: "upload"
+				}))
+			}
+		} },
+		fetchingDocs: { invoke: {
+			id: "fetchUnsignedDocs",
+			src: "fetchUnsignedDocs",
+			onDone: [{
+				target: "signing",
+				guard: "hasDocuments",
+				actions: "setDocuments"
+			}, {
+				target: "error",
+				actions: assign({
+					errorMessage: () => "aes.noDocuments",
+					errorSource: () => "fetchDocs"
+				})
+			}],
+			onError: {
+				target: "error",
+				actions: assign(({ event }) => ({
+					errorMessage: String(event.error ?? "aes.error"),
+					errorSource: "fetchDocs"
+				}))
+			}
+		} },
+		signing: { on: {
+			SET_CONSENT: { actions: "updateConsent" },
+			VIEW_DOCUMENT: { actions: "setViewingDocument" },
+			CLOSE_DOCUMENT_VIEW: { actions: "clearViewingDocument" },
+			SIGN: {
+				target: "processing",
+				guard: "allConsented"
+			},
+			CLOSE: { target: "closed" }
+		} },
+		processing: { invoke: {
+			id: "signDocuments",
+			src: "signDocuments",
+			input: ({ context }) => ({
+				documents: context.documents,
+				variant: context.config.variant ?? "ae"
+			}),
+			onDone: [
+				{
+					target: "successDownload",
+					guard: "allSignedAndDownload",
+					actions: "setSignedDocuments"
+				},
+				{
+					target: "success",
+					guard: "allSigned",
+					actions: "setSignedDocuments"
+				},
+				{
+					target: "error",
+					actions: assign({
+						errorMessage: () => "aes.signingFailed",
+						errorSource: () => "signing"
+					})
+				}
+			],
+			onError: {
+				target: "error",
+				actions: assign(({ event }) => ({
+					errorMessage: String(event.error ?? "aes.error"),
+					errorSource: "signing"
+				}))
+			}
+		} },
+		success: { after: { 3e3: "finished" } },
+		successDownload: { on: {
+			FINISH: { target: "finished" },
+			CLOSE: { target: "closed" }
+		} },
+		error: { on: {
+			RETRY: [
+				{
+					target: "uploading",
+					guard: "errorFromUpload",
+					actions: assign({
+						errorMessage: () => "",
+						errorSource: () => null,
+						fileName: () => null,
+						fileSize: () => null,
+						fileUrl: () => null
+					})
+				},
+				{
+					target: "signing",
+					guard: "errorFromSigning",
+					actions: assign({
+						errorMessage: () => "",
+						errorSource: () => null
+					})
+				},
+				{
+					target: "fetchingDocs",
+					actions: assign({
+						errorMessage: () => "",
+						errorSource: () => null
+					})
+				}
+			],
+			CLOSE: { target: "closed" }
+		} },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/internal/electronicSignature/electronicSignatureActor.ts
+function createElectronicSignatureActor(options) {
+	return createActor(electronicSignatureMachine, { input: {
+		config: options.config,
+		getFileData: options.getFileData
+	} }).start();
+}
+
+//#endregion
+//#region src/internal/electronicSignature/electronicSignatureManager.ts
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle") || snapshot.matches("fetchingDocs") || snapshot.matches("uploadingFile")) return { status: "loading" };
+	if (snapshot.matches("uploading")) return {
+		status: "uploading",
+		fileName: context.fileName
+	};
+	if (snapshot.matches("reviewing")) return {
+		status: "reviewing",
+		fileName: context.fileName,
+		fileUrl: context.fileUrl
+	};
+	if (snapshot.matches("signing")) return {
+		status: "signing",
+		variant: context.config.variant ?? "ae",
+		documents: context.documents,
+		consentChecks: context.consentChecks,
+		allConsented: areAllConsented(context.consentChecks),
+		viewingDocumentUrl: context.viewingDocumentUrl
+	};
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("success") || snapshot.matches("successDownload")) return {
+		status: "success",
+		signedDocuments: context.signedDocuments,
+		downloadDocument: context.config.downloadDocument === true
+	};
+	if (snapshot.matches("error")) return {
+		status: "error",
+		errorMessage: context.errorMessage
+	};
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("closed")) return { status: "closed" };
+	throw new Error(`Unhandled electronic-signature state: ${JSON.stringify(snapshot.value)}`);
+}
+function createApi({ actor, trackElementClicked, fileDataRef }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setConsent(name, checked) {
+			actor.send({
+				type: "SET_CONSENT",
+				name,
+				checked
+			});
+		},
+		selectFile(fileName, fileData, fileUrl) {
+			fileDataRef.current = fileData;
+			actor.send({
+				type: "SELECT_FILE",
+				fileName,
+				fileSize: fileData.byteLength,
+				fileUrl
+			});
+		},
+		replaceFile() {
+			fileDataRef.current = null;
+			actor.send({ type: "REPLACE_FILE" });
+		},
+		confirmFile() {
+			trackElementClicked?.("confirmFile");
+			actor.send({ type: "CONFIRM_FILE" });
+		},
+		viewDocument(url) {
+			actor.send({
+				type: "VIEW_DOCUMENT",
+				url
+			});
+		},
+		closeDocumentView() {
+			actor.send({ type: "CLOSE_DOCUMENT_VIEW" });
+		},
+		sign() {
+			trackElementClicked?.("sign");
+			actor.send({ type: "SIGN" });
+		},
+		finish() {
+			trackElementClicked?.("finish");
+			actor.send({ type: "FINISH" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			fileDataRef.current = null;
+			actor.send({ type: "RETRY" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+function createElectronicSignatureManager(options) {
+	const fileDataRef = { current: null };
+	return createManager({
+		actor: createElectronicSignatureActor({
+			config: options.config,
+			getFileData: () => fileDataRef.current
+		}),
+		mapState,
+		createApi: (apiOptions) => createApi({
+			...apiOptions,
+			fileDataRef
+		}),
+		instrumentation: createManagerInstrumentation(options.config.variant === "qe" ? eventModuleNames.qeSignature : eventModuleNames.aeSignature)
+	});
+}
+
+//#endregion
+export { areAllConsented as a, QE_CONSENT_KEYS as i, electronicSignatureMachine as n, getDefaultConsentChecks as o, AE_CONSENT_KEYS as r, createElectronicSignatureManager as t };