@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/identity-reuse.esm.js

@@ -0,0 +1,274 @@
+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 };

package/dist/index-BcRG8rtJ.d.ts

@@ -0,0 +1,97 @@
+import { n as Flow } from "./types-BP1m8VRw.js";
+import { t as FinishStatus } from "./flowCompletionService-DhkT4SRY.js";
+
+//#region src/internal/flow-events/flowEvents.d.ts
+type FlowStartedEvent = {
+  type: 'flow.started';
+  interviewId?: string;
+  timestamp: number;
+};
+type FlowReadyEvent = {
+  type: 'flow.ready';
+  interviewId?: string;
+  flowId?: string;
+  payload: {
+    flow: Flow;
+    steps: string[];
+    currentStep?: string;
+    currentStepIndex: number;
+  };
+  timestamp: number;
+};
+type FlowCompletedEvent = {
+  type: 'flow.completed';
+  interviewId?: string;
+  flowId?: string;
+  payload?: FinishStatus;
+  timestamp: number;
+};
+type FlowErrorEvent = {
+  type: 'flow.error';
+  interviewId?: string;
+  flowId?: string;
+  error: string;
+  timestamp: number;
+};
+type FlowClosedEvent = {
+  type: 'flow.closed';
+  interviewId?: string;
+  flowId?: string;
+  timestamp: number;
+};
+type FlowModuleStartedEvent = {
+  type: 'flow.module.started';
+  interviewId?: string;
+  flowId?: string;
+  module: string;
+  payload: {
+    moduleIndex?: number;
+    totalModules?: number;
+  };
+  timestamp: number;
+};
+type FlowModuleCompletedEvent = {
+  type: 'flow.module.completed';
+  interviewId?: string;
+  flowId?: string;
+  module: string;
+  payload: {
+    moduleIndex?: number;
+    totalModules?: number;
+  };
+  timestamp: number;
+};
+/**
+ * Curated flow event for consumers that need stable integration milestones.
+ *
+ * This local-only stream covers high-level flow state changes such as loading,
+ * readiness, module changes, completion, errors, and closure. For raw analytics
+ * events such as `screenOpened`, `elementClicked`, and
+ * `captureAttemptFinished`, use `Event` from `@incodetech/core/events`.
+ */
+type FlowEvent = FlowStartedEvent | FlowReadyEvent | FlowCompletedEvent | FlowErrorEvent | FlowClosedEvent | FlowModuleStartedEvent | FlowModuleCompletedEvent;
+type FlowEventListener = (event: FlowEvent) => void;
+/**
+ * Manager API for subscribing to curated flow milestones emitted by that
+ * specific manager instance.
+ *
+ * For raw SDK analytics events such as `screenOpened`, `elementClicked`, and
+ * `captureAttemptFinished`, use `subscribeEvent` from `@incodetech/core/events`.
+ */
+type FlowEventSubscribable = {
+  /**
+   * Subscribes to curated flow milestones for this manager instance.
+   *
+   * Use this local-only stream for product and integration milestones such as
+   * `flow.started`, `flow.ready`, `flow.module.started`,
+   * `flow.module.completed`, `flow.completed`, and `flow.error`.
+   *
+   * This stream does not queue events or post to the analytics API.
+   *
+   * @param listener - Callback function that receives each flow event.
+   * @returns Unsubscribe function to remove the listener.
+   */
+  subscribeFlowEvent(listener: FlowEventListener): () => void;
+};
+//#endregion
+export { FlowEventListener as a, FlowModuleStartedEvent as c, FlowEvent as i, FlowReadyEvent as l, FlowCompletedEvent as n, FlowEventSubscribable as o, FlowErrorEvent as r, FlowModuleCompletedEvent as s, FlowClosedEvent as t, FlowStartedEvent as u };