@incodetech/core 0.0.0-dev-20260528-e63e949b → 0.0.0-dev-20260529-ab174ea7

package/dist/identity-reuse.esm.js

@@ -1,97 +1,8 @@
 import "./api-YxPMtty2.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Bsw1l0pH.esm.js";
+import "./events-Bsw1l0pH.esm.js";
 import "./endpoints-BPHddOTi.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-CWoFJOio.esm.js";
-import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-DUCOpe0t.esm.js";
+import "./xstate.esm-CWoFJOio.esm.js";
+import { n as identityReuseMachine, t as SCAN_NEW_DOCUMENT } from "./identityReuseStateMachine-BmBxUiRQ.esm.js";
+import { n as createIdentityReuseManagerFromActor, t as createIdentityReuseManager } from "./identityReuseManager-cG0dhENk.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 { SCAN_NEW_DOCUMENT, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/identityReuseManager-DE_BcpZm.d.ts

@@ -0,0 +1,428 @@
+import { t as Manager } from "./Manager-Li1pXOFC.js";
+import { t as ActorRefFrom } from "./Actor-LDyqfWZV.js";
+import * as xstate1120 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: xstate1120.StateMachine<IdentityReuseContext, {
+  type: "LOAD";
+} | {
+  type: "DOCUMENT_CHOSEN";
+  documentId: SelectedDocumentId;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "SKIP";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate1120.ActorRefFromLogic<xstate1120.PromiseActorLogic<FetchDocumentsResponse, void, xstate1120.EventObject>> | xstate1120.ActorRefFromLogic<xstate1120.PromiseActorLogic<SubmitResponse, SubmitParams, xstate1120.EventObject>> | undefined;
+}, xstate1120.Values<{
+  fetchDocuments: {
+    src: "fetchDocuments";
+    logic: xstate1120.PromiseActorLogic<FetchDocumentsResponse, void, xstate1120.EventObject>;
+    id: string | undefined;
+  };
+  submitDocument: {
+    src: "submitDocument";
+    logic: xstate1120.PromiseActorLogic<SubmitResponse, SubmitParams, xstate1120.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate1120.Values<{
+  setDocuments: {
+    type: "setDocuments";
+    params: xstate1120.NonReducibleUnknown;
+  };
+  setError: {
+    type: "setError";
+    params: xstate1120.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate1120.NonReducibleUnknown;
+  };
+  setSelectedDocument: {
+    type: "setSelectedDocument";
+    params: xstate1120.NonReducibleUnknown;
+  };
+}>, xstate1120.Values<{
+  hasDocuments: {
+    type: "hasDocuments";
+    params: unknown;
+  };
+  hasSelection: {
+    type: "hasSelection";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "finished" | "loading" | "submitting" | "documentsFound", string, IdentityReuseInput, xstate1120.NonReducibleUnknown, xstate1120.EventObject, xstate1120.MetaObject, {
+  readonly id: "identityReuse";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchDocuments" | "submitDocument">(logic: TSrc, ...[options]: ({
+        src: "fetchDocuments";
+        logic: xstate1120.PromiseActorLogic<FetchDocumentsResponse, void, xstate1120.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchDocuments";
+        logic: xstate1120.PromiseActorLogic<FetchDocumentsResponse, void, xstate1120.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate1120.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate1120.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate1120.RequiredActorOptions<T>]: unknown }) | undefined], xstate1120.IsNotNever<xstate1120.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitDocument";
+        logic: xstate1120.PromiseActorLogic<SubmitResponse, SubmitParams, xstate1120.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitDocument";
+        logic: xstate1120.PromiseActorLogic<SubmitResponse, SubmitParams, xstate1120.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate1120.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate1120.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate1120.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate1120.IsNotNever<xstate1120.RequiredActorOptions<T_1>>> : never : never : never)): xstate1120.ActorRefFromLogic<xstate1120.GetConcreteByKey<xstate1120.Values<{
+        fetchDocuments: {
+          src: "fetchDocuments";
+          logic: xstate1120.PromiseActorLogic<FetchDocumentsResponse, void, xstate1120.EventObject>;
+          id: string | undefined;
+        };
+        submitDocument: {
+          src: "submitDocument";
+          logic: xstate1120.PromiseActorLogic<SubmitResponse, SubmitParams, xstate1120.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate1120.AnyActorLogic>(src: TLogic, ...[options]: xstate1120.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate1120.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate1120.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1120.IsNotNever<xstate1120.RequiredLogicInput<TLogic>>>): xstate1120.ActorRefFromLogic<TLogic>;
+    };
+    input: IdentityReuseInput;
+    self: xstate1120.ActorRef<xstate1120.MachineSnapshot<IdentityReuseContext, {
+      type: "LOAD";
+    } | {
+      type: "DOCUMENT_CHOSEN";
+      documentId: SelectedDocumentId;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, Record<string, xstate1120.AnyActorRef | undefined>, xstate1120.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "DOCUMENT_CHOSEN";
+      documentId: SelectedDocumentId;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, xstate1120.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/identityReuseManager-cG0dhENk.esm.js

@@ -0,0 +1,95 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Bsw1l0pH.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-CWoFJOio.esm.js";
+import { n as identityReuseMachine } from "./identityReuseStateMachine-BmBxUiRQ.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 };