@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/identity-reuse.esm.js

@@ -1,274 +1,8 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-
-//#region src/modules/identity-reuse/identityReuseServices.ts
-/** Fetches candidate organizations for identity reuse. Throws on failure. */
-async function fetchCandidates(signal) {
-	const res = await api.get(endpoints.identityReuseCandidates, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.identityReuseCandidates} failed: ${res.status} ${res.statusText} — ${JSON.stringify(res.data)}`);
-	return res.data;
-}
-/** Submits the final reuse decision. Throws on failure. */
-async function submitDecision(params, signal) {
-	const res = await api.post(endpoints.identityReuseSubmit, params, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.identityReuseSubmit} failed: ${res.status} ${res.statusText} — ${JSON.stringify(res.data)}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/modules/identity-reuse/identityReuseStateMachine.ts
-const identityReuseMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		fetchCandidates: fromPromise(async ({ signal }) => {
-			return fetchCandidates(signal);
-		}),
-		submitContinue: fromPromise(async ({ signal }) => {
-			return submitDecision({ accepted: true }, signal);
-		}),
-		submitSkip: fromPromise(async ({ signal }) => {
-			return submitDecision({ accepted: false }, signal);
-		})
-	},
-	actions: {
-		setCandidates: assign(({ event }) => {
-			const output = event.output;
-			return {
-				currentOrganizationName: output.currentOrganizationName,
-				candidateOrganizationNames: output.candidateOrganizationNames
-			};
-		}),
-		setSelectedCandidate: assign(({ event }) => {
-			return { selectedOrganizationName: event.organizationName };
-		}),
-		autoSelectSingleCandidate: assign(({ context }) => ({ selectedOrganizationName: context.candidateOrganizationNames[0] })),
-		clearSelection: assign({ selectedOrganizationName: () => void 0 }),
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		clearError: assign({ error: () => void 0 })
-	},
-	guards: {
-		hasMultipleCandidates: ({ event }) => {
-			return event.output.candidateOrganizationNames.length > 1;
-		},
-		hasOneCandidate: ({ event }) => {
-			return event.output.candidateOrganizationNames.length === 1;
-		},
-		hasChosenCandidate: ({ context }) => context.selectedOrganizationName !== void 0 && context.selectedOrganizationName.length > 0
-	}
-}).createMachine({
-	id: "identityReuse",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		currentOrganizationName: void 0,
-		candidateOrganizationNames: [],
-		selectedOrganizationName: void 0,
-		error: void 0
-	}),
-	states: {
-		idle: { on: { LOAD: { target: "loading" } } },
-		loading: { invoke: {
-			id: "fetchCandidates",
-			src: "fetchCandidates",
-			onDone: [
-				{
-					target: "multiCandidatesFound",
-					guard: "hasMultipleCandidates",
-					actions: "setCandidates"
-				},
-				{
-					target: "oneCandidateFound",
-					guard: "hasOneCandidate",
-					actions: "setCandidates"
-				},
-				{
-					target: "noCandidatesFound",
-					actions: "setCandidates"
-				}
-			],
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		multiCandidatesFound: {
-			initial: "noCandidateSelected",
-			states: {
-				noCandidateSelected: { on: { START_SELECTION: { target: "choosingCandidate" } } },
-				choosingCandidate: { on: { CANDIDATE_CHOSEN: {
-					target: "candidateSelected",
-					actions: "setSelectedCandidate"
-				} } },
-				candidateSelected: { on: { CHANGE_CANDIDATE: {
-					target: "choosingCandidate",
-					actions: "clearSelection"
-				} } }
-			},
-			on: {
-				SUBMIT_CANDIDATE: {
-					target: "submitContinue",
-					guard: "hasChosenCandidate"
-				},
-				SKIP: { target: "submitSkip" }
-			}
-		},
-		oneCandidateFound: {
-			entry: "autoSelectSingleCandidate",
-			on: {
-				SUBMIT_CANDIDATE: { target: "submitContinue" },
-				SKIP: { target: "submitSkip" }
-			}
-		},
-		noCandidatesFound: { on: { SKIP: { target: "submitSkip" } } },
-		submitContinue: { invoke: {
-			id: "submitContinue",
-			src: "submitContinue",
-			onDone: { target: "finished" },
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		submitSkip: { invoke: {
-			id: "submitSkip",
-			src: "submitSkip",
-			onDone: { target: "finished" },
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		finished: { type: "final" },
-		error: { on: {
-			RETRY: {
-				target: "loading",
-				actions: "clearError"
-			},
-			SKIP: { target: "submitSkip" }
-		} }
-	}
-});
-
-//#endregion
-//#region src/modules/identity-reuse/identityReuseActor.ts
-/**
-* Creates and starts an IdentityReuse actor.
-*
-* The actor begins in 'idle' state, ready to receive events.
-*/
-function createIdentityReuseActor(options) {
-	return createActor(identityReuseMachine, { input: { config: options.config } }).start();
-}
-
-//#endregion
-//#region src/modules/identity-reuse/identityReuseManager.ts
-function mapState(snapshot) {
-	const { context } = snapshot;
-	if (snapshot.matches("idle")) return { status: "idle" };
-	if (snapshot.matches("loading")) return { status: "loading" };
-	if (snapshot.matches("multiCandidatesFound")) {
-		let selectionPhase = "noCandidateSelected";
-		if (snapshot.matches({ multiCandidatesFound: "candidateSelected" })) selectionPhase = "candidateSelected";
-		else if (snapshot.matches({ multiCandidatesFound: "choosingCandidate" })) selectionPhase = "choosingCandidate";
-		return {
-			status: "multiCandidatesFound",
-			currentOrganizationName: context.currentOrganizationName,
-			candidateOrganizationNames: context.candidateOrganizationNames,
-			selectedOrganizationName: context.selectedOrganizationName,
-			selectionPhase
-		};
-	}
-	if (snapshot.matches("oneCandidateFound")) return {
-		status: "oneCandidateFound",
-		currentOrganizationName: context.currentOrganizationName,
-		selectedOrganizationName: context.selectedOrganizationName
-	};
-	if (snapshot.matches("noCandidatesFound")) return {
-		status: "noCandidatesFound",
-		currentOrganizationName: context.currentOrganizationName
-	};
-	if (snapshot.matches("submitContinue")) return { status: "submitContinue" };
-	if (snapshot.matches("submitSkip")) return { status: "submitSkip" };
-	if (snapshot.matches("finished")) return { status: "finished" };
-	if (snapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "An error occurred"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor, trackElementClicked }) {
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		startSelection() {
-			trackElementClicked?.("startSelection");
-			actor.send({ type: "START_SELECTION" });
-		},
-		chooseCandidate(organizationName) {
-			trackElementClicked?.("chooseCandidate");
-			actor.send({
-				type: "CANDIDATE_CHOSEN",
-				organizationName
-			});
-		},
-		changeCandidate() {
-			trackElementClicked?.("changeCandidate");
-			actor.send({ type: "CHANGE_CANDIDATE" });
-		},
-		submitCandidate() {
-			trackElementClicked?.("submitCandidate");
-			actor.send({ type: "SUBMIT_CANDIDATE" });
-		},
-		skip() {
-			trackElementClicked?.("skip");
-			actor.send({ type: "SKIP" });
-		},
-		retry() {
-			trackElementClicked?.("retry");
-			actor.send({ type: "RETRY" });
-		}
-	};
-}
-/**
-* Creates an IdentityReuse manager for headless or UI-driven usage.
-*
-* @example Headless usage
-* ```typescript
-* const manager = createIdentityReuseManager({ config: {} });
-* manager.subscribe((state) => {
-*   if (state.status === 'oneCandidateFound') manager.submitCandidate();
-*   if (state.status === 'finished') console.log('Done!');
-* });
-* manager.load();
-* ```
-*/
-function createIdentityReuseManager(options) {
-	return createManager({
-		actor: createIdentityReuseActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
-	});
-}
-/**
-* Creates an IdentityReuse manager from a pre-built actor.
-* Use this when overriding the machine via `.provide()` for custom backends or testing.
-*/
-function createIdentityReuseManagerFromActor(actor) {
-	return createManager({
-		actor,
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
-	});
-}
-
-//#endregion
-export { createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };
+import "./api-CESGtpbH.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-BfE5YiEr.esm.js";
+import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-C6n_97dw.esm.js";
+
+export { SCAN_NEW_DOCUMENT, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/identityReuseManager-C6n_97dw.esm.js

@@ -0,0 +1,95 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { n as identityReuseMachine } from "./identityReuseStateMachine-BfE5YiEr.esm.js";
+
+//#region src/modules/identity-reuse/identityReuseActor.ts
+/**
+* Creates and starts an IdentityReuse actor.
+*
+* The actor begins in 'idle' state, ready to receive events.
+*/
+function createIdentityReuseActor(options) {
+	return createActor(identityReuseMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/identity-reuse/identityReuseManager.ts
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("documentsFound")) return {
+		status: "documentsFound",
+		documents: context.documents,
+		selectedDocumentId: context.selectedDocumentId
+	};
+	if (snapshot.matches("submitting")) return { status: "submitting" };
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		chooseDocument(documentId) {
+			trackElementClicked?.("chooseDocument");
+			actor.send({
+				type: "DOCUMENT_CHOSEN",
+				documentId
+			});
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		}
+	};
+}
+/**
+* Creates an IdentityReuse manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createIdentityReuseManager({ config: {} });
+* manager.subscribe((state) => {
+*   if (state.status === 'documentsFound') manager.submit();
+*   if (state.status === 'finished') console.log('Done!');
+* });
+* manager.load();
+* ```
+*/
+function createIdentityReuseManager(options) {
+	return createManager({
+		actor: createIdentityReuseActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
+	});
+}
+/**
+* Creates an IdentityReuse manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends or testing.
+*/
+function createIdentityReuseManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
+	});
+}
+
+//#endregion
+export { createIdentityReuseManagerFromActor as n, createIdentityReuseManager as t };