@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/custom-fields.d.ts

@@ -0,0 +1,115 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region src/modules/custom-fields/types.d.ts
+type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';
+type CustomField = {
+  name: string;
+  alias: string;
+  type: CustomFieldType;
+};
+type CustomFieldsConfig = {
+  title: string;
+  customFields: CustomField[];
+};
+//#endregion
+//#region src/modules/custom-fields/customFieldsStateMachine.d.ts
+type CustomFieldsResult = 'success' | 'failed';
+declare const customFieldsMachine: any;
+//#endregion
+//#region src/modules/custom-fields/customFieldsActor.d.ts
+type CreateCustomFieldsActorOptions = {
+  config: CustomFieldsConfig;
+};
+//#endregion
+//#region src/modules/custom-fields/customFieldsManager.d.ts
+/**
+ * A `CustomField` enriched with a computed `label` for display.
+ * Label is derived from `alias` when present, otherwise auto-formatted from `name`.
+ */
+type MappedCustomField = CustomField & {
+  label: string;
+};
+/** Custom fields manager is in initial state, waiting for `load()` to be called */
+type CustomFieldsIdleState = {
+  status: 'idle';
+};
+/**
+ * Ready for field input — use `setField()` and `submit()`
+ * @property title - Form title from configuration
+ * @property customFields - Field definitions with computed display labels
+ * @property canSubmit - True when all non-boolean fields have a non-empty value
+ */
+type CustomFieldsInputtingState = {
+  status: 'inputting';
+  title: string;
+  customFields: MappedCustomField[];
+  canSubmit: boolean;
+};
+/** Fields are being submitted to the backend */
+type CustomFieldsSubmittingState = {
+  status: 'submitting';
+  title: string;
+};
+/** API call succeeded — success page is visible for ~3 s before finishing */
+type CustomFieldsSuccessState = {
+  status: 'success';
+};
+/** Custom fields flow complete. `result` indicates whether the API call succeeded or failed. */
+type CustomFieldsFinishedState = {
+  status: 'finished';
+  result: CustomFieldsResult | null;
+};
+/**
+ * Union of all possible custom fields manager states.
+ */
+type CustomFieldsState = CustomFieldsIdleState | CustomFieldsInputtingState | CustomFieldsSubmittingState | CustomFieldsSuccessState | CustomFieldsFinishedState;
+/**
+ * Creates a custom fields manager for headless or UI-driven usage.
+ *
+ * @param options - Configuration options
+ * @param options.config - Custom fields configuration (title + field definitions)
+ *
+ * @returns Custom fields manager with state, API methods, and subscription
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createCustomFieldsManager({
+ *   config: {
+ *     title: 'Additional Information',
+ *     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
+ *   },
+ * });
+ *
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * manager.setField('company', 'Incode');
+ * manager.submit();
+ * manager.stop();
+ * ```
+ */
+declare function createCustomFieldsManager(options: CreateCustomFieldsActorOptions): Manager<CustomFieldsState> & {
+  /**
+   * Initializes the custom fields flow.
+   * Transitions from 'idle' to 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the value of a single field.
+   * Should be called when state is 'inputting'.
+   *
+   * @param name - The field name (matches CustomField.name)
+   * @param value - The field value (string, number, or boolean)
+   */
+  setField(name: string, value: string | number | boolean): void;
+  /**
+   * Submits all custom field values to the backend.
+   * Transitions to 'submitting', then 'finished' regardless of outcome.
+   */
+  submit(): void;
+};
+/** Type representing a custom fields manager instance. */
+type CustomFieldsManager = ReturnType<typeof createCustomFieldsManager>;
+//#endregion
+export { type CustomField, type CustomFieldType, type CustomFieldsConfig, type CustomFieldsManager, type CustomFieldsState, type MappedCustomField, createCustomFieldsManager, customFieldsMachine };

package/dist/custom-fields.esm.js

@@ -0,0 +1,177 @@
+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";
+import { t as isoDateToMs } from "./dateUtils-UoN5xswP.esm.js";
+
+//#region src/modules/custom-fields/customFieldsServices.ts
+async function submitCustomFields(params, signal) {
+	const res = await api.post(endpoints.addCustomFields, params.fields, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCustomFields} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/custom-fields/customFieldsStateMachine.ts
+function transformFields(fields, customFields) {
+	const result = {};
+	for (const [key, value] of Object.entries(fields)) if (customFields.find((f) => f.name === key)?.type === "DATE" && typeof value === "string" && value !== "") result[key] = isoDateToMs(value);
+	else result[key] = value;
+	return result;
+}
+const customFieldsMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { submitFields: fromPromise(async ({ input, signal }) => {
+		return submitCustomFields({ fields: transformFields(input.fields, input.customFields) }, signal);
+	}) },
+	actions: {
+		setField: assign(({ context, event }) => {
+			const e = event;
+			return { fields: {
+				...context.fields,
+				[e.name]: e.value
+			} };
+		}),
+		markSuccess: assign({ result: "success" }),
+		markFailed: assign({ result: "failed" })
+	},
+	guards: { apiSucceeded: ({ event }) => event.output.success }
+}).createMachine({
+	id: "customFields",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		fields: {},
+		result: null
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "inputting" } } },
+		inputting: { on: {
+			FIELD_CHANGED: { actions: "setField" },
+			SUBMIT: { target: "submitting" }
+		} },
+		submitting: { invoke: {
+			id: "submitFields",
+			src: "submitFields",
+			input: ({ context }) => ({
+				fields: context.fields,
+				customFields: context.config.customFields
+			}),
+			onDone: [{
+				target: "success",
+				guard: "apiSucceeded"
+			}, {
+				target: "finished",
+				actions: "markFailed"
+			}],
+			onError: {
+				target: "finished",
+				actions: "markFailed"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/custom-fields/customFieldsActor.ts
+function createCustomFieldsActor(options) {
+	return createActor(customFieldsMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/custom-fields/customFieldsManager.ts
+function toDisplayLabel(field) {
+	if (field.alias) return field.alias;
+	return field.name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+function isFormComplete(fields, customFields) {
+	return customFields.every((f) => {
+		if (f.type === "BOOLEAN") return true;
+		const value = fields[f.name];
+		return value !== void 0 && value !== "";
+	});
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		title: context.config.title,
+		customFields: context.config.customFields.map((f) => ({
+			...f,
+			label: toDisplayLabel(f)
+		})),
+		canSubmit: isFormComplete(context.fields, context.config.customFields)
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.config.title
+	};
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	return {
+		status: "finished",
+		result: typedSnapshot.context.result
+	};
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setField(name, value) {
+			actor.send({
+				type: "FIELD_CHANGED",
+				name,
+				value
+			});
+		},
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		}
+	};
+}
+/**
+* Creates a custom fields manager for headless or UI-driven usage.
+*
+* @param options - Configuration options
+* @param options.config - Custom fields configuration (title + field definitions)
+*
+* @returns Custom fields manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createCustomFieldsManager({
+*   config: {
+*     title: 'Additional Information',
+*     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
+*   },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* manager.setField('company', 'Incode');
+* manager.submit();
+* manager.stop();
+* ```
+*/
+function createCustomFieldsManager(options) {
+	return createManager({
+		actor: createCustomFieldsActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customFields)
+	});
+}
+
+//#endregion
+export { createCustomFieldsManager, customFieldsMachine };

package/dist/custom-watchlist.d.ts

@@ -0,0 +1,66 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/custom-watchlist/customWatchlistStateMachine.d.ts
+type CustomWatchlistResult = 'success' | 'skipped';
+declare const customWatchlistMachine: any;
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistManager.d.ts
+type CustomWatchlistIdleState = {
+  status: 'idle';
+};
+type CustomWatchlistProcessingState = {
+  status: 'processing';
+};
+type CustomWatchlistSuccessState = {
+  status: 'success';
+};
+type CustomWatchlistFinishedState = {
+  status: 'finished';
+  result: CustomWatchlistResult;
+};
+/**
+ * Union of all possible custom watchlist manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = customWatchlistManager.getState();
+ * if (state.status === 'finished') {
+ *   console.log('Custom watchlist check complete');
+ * }
+ * ```
+ */
+type CustomWatchlistState = CustomWatchlistIdleState | CustomWatchlistProcessingState | CustomWatchlistSuccessState | CustomWatchlistFinishedState;
+/**
+ * Creates a custom watchlist manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createCustomWatchlistManager();
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * ```
+ */
+declare function createCustomWatchlistManager(): Manager<CustomWatchlistState> & {
+  /**
+   * Kicks off the custom watchlist check.
+   * Transitions from 'idle' to 'processing'.
+   */
+  load(): void;
+};
+type CustomWatchlistManager = ReturnType<typeof createCustomWatchlistManager>;
+//#endregion
+//#region src/modules/custom-watchlist/types.d.ts
+/**
+ * Configuration for the custom watchlist module (INCODE_WATCHLIST flow key).
+ *
+ * These fields are supplied by the backend flow configuration and control
+ * backend-side behaviour. They are not forwarded in the API request body —
+ * the module is fire-and-forget from the client's perspective.
+ */
+type CustomWatchlistConfig = {
+  failIfFaceOnBlocklist: boolean;
+  addSuspectedFraudAutomatically: boolean;
+  autoExecution: boolean;
+};
+//#endregion
+export { type CustomWatchlistConfig, type CustomWatchlistManager, type CustomWatchlistState, createCustomWatchlistManager, customWatchlistMachine };

package/dist/custom-watchlist.esm.js

@@ -0,0 +1,86 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./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";
+import { t as processWatchlist } from "./watchlistServices-DMbUhkBX.esm.js";
+
+//#region src/modules/custom-watchlist/customWatchlistStateMachine.ts
+const customWatchlistMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { processWatchlist: fromPromise(async ({ signal }) => {
+		await processWatchlist(signal);
+	}) },
+	actions: {
+		markSuccess: assign({ result: "success" }),
+		markSkipped: assign({ result: "skipped" })
+	}
+}).createMachine({
+	id: "customWatchlist",
+	initial: "idle",
+	context: { result: null },
+	states: {
+		idle: { on: { LOAD: { target: "processing" } } },
+		processing: { invoke: {
+			id: "processWatchlist",
+			src: "processWatchlist",
+			onDone: { target: "success" },
+			onError: {
+				target: "finished",
+				actions: "markSkipped"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistActor.ts
+function createCustomWatchlistActor() {
+	return createActor(customWatchlistMachine).start();
+}
+
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		result: typedSnapshot.context.result ?? "skipped"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return { load() {
+		actor.send({ type: "LOAD" });
+	} };
+}
+/**
+* Creates a custom watchlist manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createCustomWatchlistManager();
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* ```
+*/
+function createCustomWatchlistManager() {
+	return createManager({
+		actor: createCustomWatchlistActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customWatchList)
+	});
+}
+
+//#endregion
+export { createCustomWatchlistManager, customWatchlistMachine };

package/dist/dateUtils-UoN5xswP.esm.js

@@ -0,0 +1,23 @@
+//#region src/shared/dateUtils.ts
+/**
+* Converts an ISO date string (YYYY-MM-DD) to Unix milliseconds.
+*
+* Uses Julian Day Number arithmetic so no platform Date API is needed,
+* keeping this utility usable in any environment (browser, Node, workers).
+*
+* @param dateStr - A date string in YYYY-MM-DD format (as produced by HTML date inputs)
+* @returns Milliseconds since the Unix epoch (UTC midnight of the given date)
+*/
+function isoDateToMs(dateStr) {
+	const [yearStr = "1970", monthStr = "01", dayStr = "01"] = dateStr.split("-");
+	const y = +yearStr;
+	const m = +monthStr;
+	const d = +dayStr;
+	const a = Math.floor((14 - m) / 12);
+	const ya = y + 4800 - a;
+	const ma = m + 12 * a - 3;
+	return (d + Math.floor((153 * ma + 2) / 5) + 365 * ya + Math.floor(ya / 4) - Math.floor(ya / 100) + Math.floor(ya / 400) - 32045 - 2440588) * 864e5;
+}
+
+//#endregion
+export { isoDateToMs as t };

package/dist/deepsightLoader-Cm4JIT_z.esm.js

@@ -0,0 +1,52 @@
+import "./BaseWasmProvider-C_DLEI40.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./api-CESGtpbH.esm.js";
+import { r as BrowserEnvironmentProvider, t as IpifyProvider } from "./IpifyProvider-D7jx52AL.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import { t as createDeepsightService } from "./deepsightService-O74l4Y__.esm.js";
+import "./getBrowser-BSXUTWXw.esm.js";
+import "./stats-CIfiPzb1.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-4v7xkqAp.esm.js";
+
+//#region ../infra/src/providers/browser/VisibilityProvider.ts
+var VisibilityProvider = class {
+	constructor() {
+		this._wasBackgrounded = false;
+		this.visibilityChangeHandler = this.onVisibilityChange.bind(this);
+		document.addEventListener("visibilitychange", this.visibilityChangeHandler);
+	}
+	get wasBackgrounded() {
+		return this._wasBackgrounded;
+	}
+	reset() {
+		this._wasBackgrounded = false;
+	}
+	cleanup() {
+		document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
+	}
+	onVisibilityChange() {
+		if (document.hidden) this._wasBackgrounded = true;
+	}
+};
+
+//#endregion
+//#region src/internal/deepsight/deepsightLoader.ts
+const SDK_VERSION = "2.0.0";
+async function loadDeepsightSession(options) {
+	await options.storage.set("ds", options.ds ? 1 : 0);
+	const service = createDeepsightService({
+		sdkVersion: SDK_VERSION,
+		wasmUtil: await WasmUtilProvider.getInstance(),
+		visibility: new VisibilityProvider(),
+		browserEnv: new BrowserEnvironmentProvider(),
+		motionSensor: new MotionSensorProvider(),
+		ipLookup: new IpifyProvider()
+	});
+	await service.initialize(options.disableIpify);
+	await service.startMotionSensors();
+	return service;
+}
+
+//#endregion
+export { loadDeepsightSession };