@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/identityReuseManager-DwLtVzUn.d.ts

@@ -0,0 +1,428 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import * as xstate0 from "xstate";
+
+//#region src/modules/identity-reuse/types.d.ts
+
+/**
+ * Configuration options for the IdentityReuse module.
+ *
+ * @example
+ * ```typescript
+ * const config: IdentityReuseConfig = {};
+ * ```
+ */
+type IdentityReuseConfig = {};
+/**
+ * A reusable identity document previously verified with a partner organization.
+ * Internal shape consumed by the state machine, manager, and UI; the service
+ * layer adapts the raw backend payload to this shape.
+ *
+ * Backend orders the array — the first entry is the best match. The
+ * "Recommended" tag in the UI is purely positional; no backend field for it.
+ */
+type ReusableDocument = {
+  /** Stable document identifier (uuid). Used as `documentId` in submit. */
+  id: string;
+  /** Document category, normalized to camelCase (e.g. "driversLicense"). */
+  documentType: string;
+  /** Masked identifier shown to the user (e.g. "00*****29"). */
+  maskedNumber: string;
+  /**
+   * Country code as returned by the backend (ISO 3166-1 alpha-3, e.g. "SRB").
+   * UI is responsible for any presentation transforms (flag emoji, etc.).
+   */
+  countryCode: string;
+  /**
+   * Verification timestamp as a Unix epoch in seconds (may include fractional
+   * milliseconds). Pass-through from the backend's `validatedAt`; the UI layer
+   * is responsible for any Date construction or formatting.
+   */
+  verifiedAt: number;
+};
+/**
+ * Documents returned by the service layer after adapting the backend payload.
+ * Always an array; ordered by backend with the best match first.
+ */
+type FetchDocumentsResponse = ReusableDocument[];
+/**
+ * @internal Request body for POST /omni/identity-reuse/submit.
+ *
+ * - `{ accepted: true, documentId }` — user is reusing the selected document.
+ * - `{ accepted: false }` — user opted to scan a new document instead.
+ */
+type SubmitParams = {
+  accepted: true;
+  documentId: string;
+} | {
+  accepted: false;
+};
+/** @internal Response from POST /omni/identity-reuse/submit — shape TBD */
+type SubmitResponse = {};
+//#endregion
+//#region src/modules/identity-reuse/identityReuseStateMachine.d.ts
+/**
+ * Sentinel selection value for the "Scan a new document" row in the picker.
+ * Picked + SUBMIT calls /submit with `{ accepted: false }`, then finishes.
+ */
+declare const SCAN_NEW_DOCUMENT: "scanNew";
+type SelectedDocumentId = string | typeof SCAN_NEW_DOCUMENT;
+type IdentityReuseContext = {
+  config: IdentityReuseConfig;
+  documents: ReusableDocument[];
+  selectedDocumentId: SelectedDocumentId | undefined;
+  error: string | undefined;
+};
+type IdentityReuseInput = {
+  config: IdentityReuseConfig;
+};
+declare const identityReuseMachine: xstate0.StateMachine<IdentityReuseContext, {
+  type: "LOAD";
+} | {
+  type: "DOCUMENT_CHOSEN";
+  documentId: SelectedDocumentId;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "SKIP";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<FetchDocumentsResponse, void, xstate0.EventObject>> | xstate0.ActorRefFromLogic<xstate0.PromiseActorLogic<SubmitResponse, SubmitParams, xstate0.EventObject>> | undefined;
+}, xstate0.Values<{
+  fetchDocuments: {
+    src: "fetchDocuments";
+    logic: xstate0.PromiseActorLogic<FetchDocumentsResponse, void, xstate0.EventObject>;
+    id: string | undefined;
+  };
+  submitDocument: {
+    src: "submitDocument";
+    logic: xstate0.PromiseActorLogic<SubmitResponse, SubmitParams, xstate0.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate0.Values<{
+  setDocuments: {
+    type: "setDocuments";
+    params: xstate0.NonReducibleUnknown;
+  };
+  setSelectedDocument: {
+    type: "setSelectedDocument";
+    params: xstate0.NonReducibleUnknown;
+  };
+  setError: {
+    type: "setError";
+    params: xstate0.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate0.NonReducibleUnknown;
+  };
+}>, xstate0.Values<{
+  hasDocuments: {
+    type: "hasDocuments";
+    params: unknown;
+  };
+  hasSelection: {
+    type: "hasSelection";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "finished" | "loading" | "documentsFound" | "submitting", string, IdentityReuseInput, xstate0.NonReducibleUnknown, xstate0.EventObject, xstate0.MetaObject, {
+  readonly id: "identityReuse";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchDocuments" | "submitDocument">(logic: TSrc, ...[options]: ({
+        src: "fetchDocuments";
+        logic: xstate0.PromiseActorLogic<FetchDocumentsResponse, void, xstate0.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchDocuments";
+        logic: xstate0.PromiseActorLogic<FetchDocumentsResponse, void, 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) | ({
+        src: "submitDocument";
+        logic: xstate0.PromiseActorLogic<SubmitResponse, SubmitParams, xstate0.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitDocument";
+        logic: xstate0.PromiseActorLogic<SubmitResponse, SubmitParams, xstate0.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate0.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate0.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate0.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredActorOptions<T_1>>> : never : never : never)): xstate0.ActorRefFromLogic<xstate0.GetConcreteByKey<xstate0.Values<{
+        fetchDocuments: {
+          src: "fetchDocuments";
+          logic: xstate0.PromiseActorLogic<FetchDocumentsResponse, void, xstate0.EventObject>;
+          id: string | undefined;
+        };
+        submitDocument: {
+          src: "submitDocument";
+          logic: xstate0.PromiseActorLogic<SubmitResponse, SubmitParams, 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: IdentityReuseInput;
+    self: xstate0.ActorRef<xstate0.MachineSnapshot<IdentityReuseContext, {
+      type: "LOAD";
+    } | {
+      type: "DOCUMENT_CHOSEN";
+      documentId: SelectedDocumentId;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, Record<string, xstate0.AnyActorRef | undefined>, xstate0.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "DOCUMENT_CHOSEN";
+      documentId: SelectedDocumentId;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, xstate0.AnyEventObject>;
+  }) => {
+    config: IdentityReuseConfig;
+    documents: never[];
+    selectedDocumentId: undefined;
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchDocuments";
+        readonly src: "fetchDocuments";
+        readonly onDone: readonly [{
+          readonly target: "documentsFound";
+          readonly guard: "hasDocuments";
+          readonly actions: "setDocuments";
+        }, {
+          readonly target: "finished";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly documentsFound: {
+      readonly on: {
+        readonly DOCUMENT_CHOSEN: {
+          readonly actions: "setSelectedDocument";
+        };
+        readonly SUBMIT: {
+          readonly target: "submitting";
+          readonly guard: "hasSelection";
+        };
+        readonly SKIP: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submitDocument";
+        readonly src: "submitDocument";
+        readonly input: ({
+          context
+        }: {
+          context: IdentityReuseContext;
+        }) => SubmitParams;
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly SKIP: {
+          readonly target: "finished";
+        };
+      };
+    };
+  };
+}>;
+type IdentityReuseMachine = typeof identityReuseMachine;
+//#endregion
+//#region src/modules/identity-reuse/identityReuseActor.d.ts
+/**
+ * Options for creating an IdentityReuse actor.
+ */
+type CreateIdentityReuseActorOptions = {
+  /** Module configuration */
+  config: IdentityReuseConfig;
+};
+/**
+ * Type representing a running IdentityReuse actor.
+ */
+type IdentityReuseActor = ActorRefFrom<IdentityReuseMachine>;
+//#endregion
+//#region src/modules/identity-reuse/identityReuseManager.d.ts
+/** IdentityReuse manager is in initial state, waiting for `load()` */
+type IdentityReuseIdleState = {
+  status: 'idle';
+};
+/** Fetching reusable documents from the backend */
+type IdentityReuseLoadingState = {
+  status: 'loading';
+};
+/**
+ * Documents are available — user picks one (or "scan new") and confirms.
+ * The first document in the list is the recommended one; the UI surfaces a
+ * "Recommended" tag based on position alone.
+ *
+ * @property documents - Ordered documents; index 0 is the best match.
+ * @property selectedDocumentId - Currently selected document id, or
+ *   `'scanNew'` if the user picked the scan-new row. Auto-populated to
+ *   `documents[0].id` on entry.
+ */
+type IdentityReuseDocumentsFoundState = {
+  status: 'documentsFound';
+  documents: ReusableDocument[];
+  selectedDocumentId: SelectedDocumentId | undefined;
+};
+/** Submitting the chosen document for reuse */
+type IdentityReuseSubmittingState = {
+  status: 'submitting';
+};
+/** Module completed successfully */
+type IdentityReuseFinishedState = {
+  status: 'finished';
+};
+/**
+ * A recoverable error occurred — user can retry or skip
+ * @property error - Error message describing what went wrong
+ */
+type IdentityReuseErrorState = {
+  status: 'error';
+  error: string;
+};
+/**
+ * Union of all possible IdentityReuse manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = manager.getState();
+ * if (state.status === 'documentsFound') {
+ *   console.log(state.documents);
+ * }
+ * ```
+ */
+type IdentityReuseState = IdentityReuseIdleState | IdentityReuseLoadingState | IdentityReuseDocumentsFoundState | IdentityReuseSubmittingState | IdentityReuseFinishedState | IdentityReuseErrorState;
+/**
+ * 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();
+ * ```
+ */
+declare function createIdentityReuseManager(options: CreateIdentityReuseActorOptions): Manager<IdentityReuseState> & {
+  /**
+   * Fetches reusable documents from the backend.
+   * Transitions from 'idle' to 'loading'.
+   */
+  load(): void;
+  /**
+   * Selects a document by id, or the `'scanNew'` sentinel to indicate the
+   * user prefers to scan a new document instead of reusing one.
+   */
+  chooseDocument(documentId: SelectedDocumentId): void;
+  /**
+   * Confirms the current selection. If a document is selected, submits it
+   * for reuse; if the scan-new row is selected, finishes the module without
+   * submitting (orchestration will load the next node).
+   */
+  submit(): void;
+  /**
+   * Skips identity reuse entirely. Finishes the module without submitting;
+   * orchestration moves on to the next node.
+   */
+  skip(): void;
+  /**
+   * Retries loading documents after an error.
+   */
+  retry(): void;
+};
+/**
+ * Creates an IdentityReuse manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends or testing.
+ */
+declare function createIdentityReuseManagerFromActor(actor: IdentityReuseActor): Manager<IdentityReuseState> & {
+  /**
+   * Fetches reusable documents from the backend.
+   * Transitions from 'idle' to 'loading'.
+   */
+  load(): void;
+  /**
+   * Selects a document by id, or the `'scanNew'` sentinel to indicate the
+   * user prefers to scan a new document instead of reusing one.
+   */
+  chooseDocument(documentId: SelectedDocumentId): void;
+  /**
+   * Confirms the current selection. If a document is selected, submits it
+   * for reuse; if the scan-new row is selected, finishes the module without
+   * submitting (orchestration will load the next node).
+   */
+  submit(): void;
+  /**
+   * Skips identity reuse entirely. Finishes the module without submitting;
+   * orchestration moves on to the next node.
+   */
+  skip(): void;
+  /**
+   * Retries loading documents after an error.
+   */
+  retry(): void;
+};
+type IdentityReuseManager = ReturnType<typeof createIdentityReuseManager>;
+//#endregion
+export { IdentityReuseActor as a, identityReuseMachine as c, ReusableDocument as d, SubmitResponse as f, createIdentityReuseManagerFromActor as i, FetchDocumentsResponse as l, IdentityReuseState as n, SCAN_NEW_DOCUMENT as o, createIdentityReuseManager as r, SelectedDocumentId as s, IdentityReuseManager as t, IdentityReuseConfig as u };

package/dist/identityReuseStateMachine-BfE5YiEr.esm.js

@@ -0,0 +1,148 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+
+//#region src/modules/identity-reuse/identityReuseServices.ts
+function lowerFirstLetter(value) {
+	if (!value) return value;
+	return value.charAt(0).toLowerCase() + value.slice(1);
+}
+/**
+* Coerces a backend timestamp into a finite number (unix seconds).
+* Backend sends `validatedAt` as a JSON number but some gateways serialize
+* floats as strings; this guard accepts both and yields NaN otherwise so the
+* UI can hide the verified line for unparseable values.
+*/
+function coerceTimestamp(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return NaN;
+}
+function adaptDocument(doc) {
+	return {
+		id: doc.documentId,
+		documentType: lowerFirstLetter(doc.type),
+		maskedNumber: doc.documentNumber,
+		countryCode: doc.countryCode,
+		verifiedAt: coerceTimestamp(doc.validatedAt)
+	};
+}
+/** Fetches reusable identity documents. Throws on failure. */
+async function fetchDocuments(signal) {
+	const res = await api.get(endpoints.identityReuseDocuments, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.identityReuseDocuments} failed: ${res.status} ${res.statusText} — ${JSON.stringify(res.data)}`);
+	return (res.data?.documents ?? []).map(adaptDocument);
+}
+/** Submits the chosen document (or scan-new) for reuse. Throws on failure. */
+async function submitDocument(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
+/**
+* Sentinel selection value for the "Scan a new document" row in the picker.
+* Picked + SUBMIT calls /submit with `{ accepted: false }`, then finishes.
+*/
+const SCAN_NEW_DOCUMENT = "scanNew";
+function deriveSubmitParams(selectedDocumentId) {
+	if (selectedDocumentId === SCAN_NEW_DOCUMENT || !selectedDocumentId) return { accepted: false };
+	return {
+		accepted: true,
+		documentId: selectedDocumentId
+	};
+}
+const identityReuseMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchDocuments: fromPromise(async ({ signal }) => {
+			return fetchDocuments(signal);
+		}),
+		submitDocument: fromPromise(async ({ input, signal }) => {
+			return submitDocument(input, signal);
+		})
+	},
+	actions: {
+		setDocuments: assign(({ event }) => {
+			const output = event.output;
+			return {
+				documents: output,
+				selectedDocumentId: output[0]?.id
+			};
+		}),
+		setSelectedDocument: assign(({ event }) => {
+			return { selectedDocumentId: event.documentId };
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 })
+	},
+	guards: {
+		hasDocuments: ({ event }) => {
+			return event.output.length > 0;
+		},
+		hasSelection: ({ context }) => context.selectedDocumentId !== void 0
+	}
+}).createMachine({
+	id: "identityReuse",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		documents: [],
+		selectedDocumentId: void 0,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "loading" } } },
+		loading: { invoke: {
+			id: "fetchDocuments",
+			src: "fetchDocuments",
+			onDone: [{
+				target: "documentsFound",
+				guard: "hasDocuments",
+				actions: "setDocuments"
+			}, { target: "finished" }],
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		documentsFound: { on: {
+			DOCUMENT_CHOSEN: { actions: "setSelectedDocument" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "hasSelection"
+			},
+			SKIP: { target: "finished" }
+		} },
+		submitting: { invoke: {
+			id: "submitDocument",
+			src: "submitDocument",
+			input: ({ context }) => deriveSubmitParams(context.selectedDocumentId),
+			onDone: { target: "finished" },
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		finished: { type: "final" },
+		error: { on: {
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			},
+			SKIP: { target: "finished" }
+		} }
+	}
+});
+
+//#endregion
+export { identityReuseMachine as n, SCAN_NEW_DOCUMENT as t };

package/dist/{index-BcRG8rtJ.d.ts → index-B5hPA0Bg.d.ts}

@@ -1,5 +1,5 @@
-import { n as Flow } from "./types-BP1m8VRw.js";
-import { t as FinishStatus } from "./flowCompletionService-DhkT4SRY.js";
+import { n as Flow } from "./types-DOUhndhT.js";
+import { t as FinishStatus } from "./flowCompletionService-BdR2cGgB.js";
 
 //#region src/internal/flow-events/flowEvents.d.ts
 type FlowStartedEvent = {