@incodetech/core 2.0.0 → 2.0.1

package/dist/signature.d.ts

@@ -0,0 +1,94 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region src/modules/signature/types.d.ts
+/**
+ * Configuration options for Signature.
+ */
+type SignatureConfig = {
+  type?: string;
+  /**
+   * Optional header title for both steps. When omitted, the UI uses per-step defaults
+   * (“Draw your signature”).
+   */
+  title?: string;
+  /**
+   * Optional subtitle for both steps. When omitted, the UI uses the default finger/mouse copy.
+   * Backend field name: `subTitle` (capital T).
+   */
+  subTitle?: string;
+  /**
+   * When true, uploads base64 via Omni `addSignature` v2 JSON body.
+   * When false (default), uploads JPEG bytes (`image/jpeg`).
+   */
+  sendBase64?: boolean;
+  /**
+   * Optional fill behind the drawing area (e.g. hex, `rgb()`, or a CSS variable).
+   * When omitted, the default themed surface from the signature UI is used.
+   */
+  canvasBackgroundColor?: string;
+  /**
+   * Optional maximum stroke width for the pen, in CSS pixels (passed to `SignaturePad` as `maxWidth`).
+   * When omitted, the pad uses its default sizing.
+   */
+  penStrokeWidth?: number;
+  /**
+   * Optional ink color (e.g. hex, `rgb()`, or `var(--token)` resolved where supported).
+   * When omitted, the default signature pen color from theme tokens is used.
+   */
+  penColor?: string;
+  /**
+   * Optional border color for the drawing area (same format as `penColor`).
+   * When omitted, the default input border token from the signature UI is used.
+   */
+  canvasBorderColor?: string;
+};
+/** Response body from Omni add-signature endpoints. */
+type AddSignatureResponse = {
+  image: string | Blob;
+  type: string;
+};
+//#endregion
+//#region src/modules/signature/signatureStateMachine.d.ts
+
+declare const signatureMachine: any;
+//#endregion
+//#region src/modules/signature/signatureActor.d.ts
+type CreateSignatureActorOptions = {
+  config: SignatureConfig;
+};
+//#endregion
+//#region src/modules/signature/signatureManager.d.ts
+type SignatureIdleState = {
+  status: 'idle';
+};
+type SignatureCaptureState = {
+  status: 'capture';
+  title: string | undefined;
+  subtitle: string | undefined;
+  canContinue: boolean;
+};
+type SignatureSubmittingState = {
+  status: 'submitting';
+};
+type SignatureFinishedState = {
+  status: 'finished';
+  result: AddSignatureResponse | undefined;
+};
+type SignatureErrorState = {
+  status: 'error';
+  error: string;
+};
+type SignatureSuccessState = {
+  status: 'success';
+};
+type SignatureState = SignatureIdleState | SignatureCaptureState | SignatureSubmittingState | SignatureFinishedState | SignatureErrorState | SignatureSuccessState;
+declare function createSignatureManager(options: CreateSignatureActorOptions): Manager<SignatureState> & {
+  load(): void;
+  setSignatureValid(isValid: boolean): void;
+  /** Exported image (base64 string or JPEG Blob) from the canvas; starts the upload actor. */
+  submit(image: string | Blob): void;
+};
+type SignatureManager = ReturnType<typeof createSignatureManager>;
+//#endregion
+export { type SignatureCaptureState, type SignatureConfig, type SignatureManager, type SignatureState, createSignatureManager, signatureMachine };

package/dist/signature.esm.js

@@ -0,0 +1,66 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as signatureMachine } from "./signatureStateMachine-B5-QVUve.esm.js";
+
+//#region src/modules/signature/signatureActor.ts
+function createSignatureActor(options) {
+	return createActor(signatureMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/signature/signatureManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("captureSignature")) return {
+		status: "capture",
+		title: context.config.title,
+		subtitle: context.config.subTitle,
+		canContinue: context.isValid
+	};
+	if (typedSnapshot.matches("submittingSignature")) return { status: "submitting" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		result: context.signatureSubmitResult
+	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Upload failed"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setSignatureValid(isValid) {
+			actor.send({
+				type: "SIGNATURE_CHANGED",
+				isValid
+			});
+		},
+		submit(image) {
+			trackElementClicked?.("continue");
+			actor.send({
+				type: "CONTINUE",
+				image
+			});
+		}
+	};
+}
+function createSignatureManager(options) {
+	return createManager({
+		actor: createSignatureActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.signature)
+	});
+}
+
+//#endregion
+export { createSignatureManager, signatureMachine };

package/dist/signatureStateMachine-B5-QVUve.esm.js

@@ -0,0 +1,132 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { h as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-D6-e4vok.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/signature/signatureServices.ts
+/**
+* Uploads a signature image to the Omni API.
+* Uses JSON + base64 when `sendBase64` is true, otherwise sends raw JPEG bytes.
+* Throws on failure.
+*/
+async function addSignature(params, signal) {
+	const { image, type, sendBase64 = false } = params;
+	const url = sendBase64 ? endpoints.addSignatureV2 : endpoints.addSignature;
+	const body = sendBase64 ? { base64Image: image } : image;
+	const res = await api.post(url, body, {
+		signal,
+		headers: { "Content-Type": sendBase64 ? "application/json" : "image/jpeg" },
+		query: { type }
+	});
+	if (!res.ok) throw new Error(`POST ${url} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/signature/signatureStateMachine.ts
+function emptyCaptureState() {
+	return {
+		image: void 0,
+		isValid: false,
+		error: void 0,
+		signatureSubmitResult: void 0
+	};
+}
+const signatureMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { submitSignature: fromPromise(async ({ input, signal }) => {
+		const { ...params } = input;
+		return addSignature(params, signal);
+	}) },
+	actions: {
+		setSignatureValidity: assign(({ event }) => {
+			return {
+				isValid: event.isValid,
+				error: void 0
+			};
+		}),
+		assignImageForSubmit: assign(({ event }) => {
+			return {
+				image: event.image,
+				error: void 0
+			};
+		}),
+		setSignatureSubmitResult: assign(({ event }) => ({
+			signatureSubmitResult: event.output,
+			error: void 0
+		})),
+		setErrorFromInvoke: assign(({ event }) => {
+			const error = event.error;
+			return { error: error instanceof Error ? error.message : typeof error === "string" ? error : "Something went wrong" };
+		}),
+		clearError: assign({ error: () => void 0 }),
+		resetContext: assign({
+			isValid: () => false,
+			image: () => void 0,
+			error: () => void 0
+		}),
+		trackSubmitAttempt: () => {
+			addEvent({
+				code: "continue",
+				module: eventModuleNames.signature,
+				screen: eventScreenNames.signatureInput
+			});
+		},
+		trackError: ({ context }) => {
+			addEvent({
+				code: "verificationError",
+				module: eventModuleNames.signature,
+				payload: context.error ? { error: context.error } : void 0
+			});
+		}
+	},
+	guards: { canContinue: ({ context, event }) => context.isValid && event.type === "CONTINUE" && !!event.image }
+}).createMachine({
+	id: "signature",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		...emptyCaptureState()
+	}),
+	states: {
+		idle: { on: { LOAD: "captureSignature" } },
+		captureSignature: { on: {
+			SIGNATURE_CHANGED: { actions: "setSignatureValidity" },
+			CONTINUE: {
+				target: "submittingSignature",
+				guard: "canContinue",
+				actions: "assignImageForSubmit"
+			}
+		} },
+		submittingSignature: {
+			entry: "trackSubmitAttempt",
+			invoke: {
+				id: "submitSignature",
+				src: "submitSignature",
+				input: ({ context }) => ({
+					image: context.image,
+					type: context.config.type,
+					sendBase64: context.config.sendBase64 ?? false
+				}),
+				onDone: {
+					target: "success",
+					actions: "setSignatureSubmitResult"
+				},
+				onError: {
+					target: "error",
+					actions: "setErrorFromInvoke"
+				}
+			}
+		},
+		success: { after: { 3e3: "finished" } },
+		finished: { type: "final" },
+		error: { entry: "trackError" }
+	}
+});
+
+//#endregion
+export { signatureMachine as t };

package/dist/stats-CIfiPzb1.esm.js

@@ -0,0 +1,16 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+
+//#region src/modules/stats/statsServices.ts
+/**
+* Sends device stats to the backend.
+*/
+async function addDeviceStats(stats) {
+	try {
+		await api.post("/omni/device/stats", stats);
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { addDeviceStats as t };

package/dist/stats.d.ts

@@ -0,0 +1,16 @@
+//#region src/modules/stats/statsServices.d.ts
+type LabelInspectionStatus = 'FAIL' | 'PASS';
+type DeviceStats = {
+  cameraLabelInspectionStatus?: LabelInspectionStatus;
+  virtualCameraDetected?: boolean;
+  frontIdStatsAnalysisStatus?: string;
+  backIdStatsAnalysisStatus?: string;
+  selfieStatsAnalysisStatus?: string;
+  motionStatus?: string;
+};
+/**
+ * Sends device stats to the backend.
+ */
+declare function addDeviceStats(stats: DeviceStats): Promise<void>;
+//#endregion
+export { type DeviceStats, type LabelInspectionStatus, addDeviceStats };

package/dist/stats.esm.js

@@ -0,0 +1,4 @@
+import "./api-CESGtpbH.esm.js";
+import { t as addDeviceStats } from "./stats-CIfiPzb1.esm.js";
+
+export { addDeviceStats };

package/dist/trust-graph.d.ts

@@ -0,0 +1,54 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/trust-graph/trustGraphManager.d.ts
+type TrustGraphIdleState = {
+  status: 'idle';
+};
+type TrustGraphFinishedState = {
+  status: 'finished';
+};
+/**
+ * Union of all possible trust-graph manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = trustGraphManager.getState();
+ * if (state.status === 'finished') {
+ *   console.log('Trust graph check complete');
+ * }
+ * ```
+ */
+type TrustGraphState = TrustGraphIdleState | TrustGraphFinishedState;
+/**
+ * Creates a trust-graph manager for headless usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createTrustGraphManager();
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * ```
+ */
+declare function createTrustGraphManager(): Manager<TrustGraphState> & {
+  /**
+   * Kicks off the trust-graph module.
+   * Transitions immediately from 'idle' to 'finished' (backend-only, no SDK action).
+   */
+  load(): void;
+};
+type TrustGraphManager = ReturnType<typeof createTrustGraphManager>;
+//#endregion
+//#region src/modules/trust-graph/trustGraphStateMachine.d.ts
+declare const trustGraphMachine: any;
+//#endregion
+//#region src/modules/trust-graph/types.d.ts
+/**
+ * Configuration options for the trust-graph module.
+ *
+ * The trust-graph module requires no configuration — it is a backend-only
+ * process that runs risk scoring analysis server-side. The SDK skips
+ * immediately without any user interaction.
+ */
+type TrustGraphConfig = Record<string, never>;
+//#endregion
+export { type TrustGraphConfig, type TrustGraphFinishedState, type TrustGraphManager, type TrustGraphState, createTrustGraphManager, trustGraphMachine };

package/dist/trust-graph.esm.js

@@ -0,0 +1,56 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import { c as createManager, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/trust-graph/trustGraphStateMachine.ts
+const trustGraphMachine = setup({ types: {
+	context: {},
+	events: {}
+} }).createMachine({
+	id: "trust-graph",
+	initial: "idle",
+	context: {},
+	states: {
+		idle: { on: { LOAD: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/trust-graph/trustGraphActor.ts
+function createTrustGraphActor() {
+	return createActor(trustGraphMachine).start();
+}
+
+//#endregion
+//#region src/modules/trust-graph/trustGraphManager.ts
+function mapState(snapshot) {
+	if (snapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return { load() {
+		actor.send({ type: "LOAD" });
+	} };
+}
+/**
+* Creates a trust-graph manager for headless usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createTrustGraphManager();
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* ```
+*/
+function createTrustGraphManager() {
+	return createManager({
+		actor: createTrustGraphActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.trustGraph)
+	});
+}
+
+//#endregion
+export { createTrustGraphManager, trustGraphMachine };

package/dist/types-B06Ypu2F.d.ts

@@ -0,0 +1,49 @@
+import { t as AnyStateMachine } from "./StateMachine-BCQrZJhf.js";
+
+//#region src/internal/orchestration/types.d.ts
+/** Eager module: a pre-imported state machine. */
+type EagerModule = AnyStateMachine;
+/** Lazy module: a function that dynamically imports a state machine. */
+type LazyModule = () => Promise<AnyStateMachine>;
+/** A module entry in the registry — either eager (pre-loaded) or lazy (dynamically loaded). */
+type ModuleEntry = EagerModule | LazyModule;
+/**
+ * Registry mapping module keys to state machines.
+ * Used by Flow (eager-only) — all entries are AnyStateMachine.
+ */
+type ModuleRegistry = {
+  [key: string]: AnyStateMachine | undefined;
+};
+/**
+ * Extended registry supporting both eager and lazy module entries.
+ * Used by Workflow — entries can be pre-loaded machines or dynamic import functions.
+ */
+type WorkflowModuleRegistry = {
+  [key: string]: ModuleEntry | undefined;
+};
+/**
+ * Per-module config remapping for orchestrators.
+ *
+ * The backend's workflow-node `moduleConfiguration` shape doesn't always match
+ * the shape a module's manager / state machine expects. A mapper converts the
+ * raw node config into the module's `Config` type. Identity is the default
+ * when no mapper is registered.
+ *
+ * Mapping is owned by core (not the UI layer) so that core-only consumers of
+ * `createWorkflowManager` get correctly shaped configs without depending on
+ * `@incodetech/web`.
+ */
+type ModuleConfigMapper = (raw: unknown) => unknown;
+type ModuleConfigMappers = Record<string, ModuleConfigMapper>;
+type RunChildModuleInput = {
+  machine: AnyStateMachine | undefined;
+  config: unknown;
+};
+type RunChildModuleEvent = {
+  type: 'MODULE_COMPLETE';
+} | {
+  type: 'MODULE_ERROR';
+  error: unknown;
+};
+//#endregion
+export { WorkflowModuleRegistry as a, RunChildModuleInput as i, ModuleRegistry as n, RunChildModuleEvent as r, ModuleConfigMappers as t };