@incodetech/core 0.0.0-dev-20260313-8b7649e → 0.0.0-dev-20260316-0522f9e

package/dist/Actor-D3GOC38V.d.ts

@@ -0,0 +1,2 @@
+import { ActorRefFrom, createActor } from "xstate";
+export { createActor as n, ActorRefFrom as t };

package/dist/StateMachine-BFurBmbZ.d.ts

@@ -0,0 +1,2 @@
+import { AnyStateMachine, StateMachine, fromPromise } from "xstate";
+export { StateMachine as n, fromPromise as r, AnyStateMachine as t };

package/dist/addressSearch-B446UZn4.esm.js

@@ -0,0 +1,423 @@
+import { g as BrowserTimerProvider } from "./src-D0bFtylT.esm.js";
+import { r as fromCallback } from "./xstate.esm-CcoTezCZ.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
+
+//#region src/shared/usStates.ts
+const usStates = {
+	AL: {
+		code: "AL",
+		name: "Alabama"
+	},
+	AK: {
+		code: "AK",
+		name: "Alaska"
+	},
+	AZ: {
+		code: "AZ",
+		name: "Arizona"
+	},
+	AR: {
+		code: "AR",
+		name: "Arkansas"
+	},
+	CA: {
+		code: "CA",
+		name: "California"
+	},
+	CO: {
+		code: "CO",
+		name: "Colorado"
+	},
+	CT: {
+		code: "CT",
+		name: "Connecticut"
+	},
+	DE: {
+		code: "DE",
+		name: "Delaware"
+	},
+	FL: {
+		code: "FL",
+		name: "Florida"
+	},
+	GA: {
+		code: "GA",
+		name: "Georgia"
+	},
+	HI: {
+		code: "HI",
+		name: "Hawaii"
+	},
+	ID: {
+		code: "ID",
+		name: "Idaho"
+	},
+	IL: {
+		code: "IL",
+		name: "Illinois"
+	},
+	IN: {
+		code: "IN",
+		name: "Indiana"
+	},
+	IA: {
+		code: "IA",
+		name: "Iowa"
+	},
+	KS: {
+		code: "KS",
+		name: "Kansas"
+	},
+	KY: {
+		code: "KY",
+		name: "Kentucky"
+	},
+	LA: {
+		code: "LA",
+		name: "Louisiana"
+	},
+	ME: {
+		code: "ME",
+		name: "Maine"
+	},
+	MD: {
+		code: "MD",
+		name: "Maryland"
+	},
+	MA: {
+		code: "MA",
+		name: "Massachusetts"
+	},
+	MI: {
+		code: "MI",
+		name: "Michigan"
+	},
+	MN: {
+		code: "MN",
+		name: "Minnesota"
+	},
+	MS: {
+		code: "MS",
+		name: "Mississippi"
+	},
+	MO: {
+		code: "MO",
+		name: "Missouri"
+	},
+	MT: {
+		code: "MT",
+		name: "Montana"
+	},
+	NE: {
+		code: "NE",
+		name: "Nebraska"
+	},
+	NV: {
+		code: "NV",
+		name: "Nevada"
+	},
+	NH: {
+		code: "NH",
+		name: "New Hampshire"
+	},
+	NJ: {
+		code: "NJ",
+		name: "New Jersey"
+	},
+	NM: {
+		code: "NM",
+		name: "New Mexico"
+	},
+	NY: {
+		code: "NY",
+		name: "New York"
+	},
+	NC: {
+		code: "NC",
+		name: "North Carolina"
+	},
+	ND: {
+		code: "ND",
+		name: "North Dakota"
+	},
+	OH: {
+		code: "OH",
+		name: "Ohio"
+	},
+	OK: {
+		code: "OK",
+		name: "Oklahoma"
+	},
+	OR: {
+		code: "OR",
+		name: "Oregon"
+	},
+	PA: {
+		code: "PA",
+		name: "Pennsylvania"
+	},
+	RI: {
+		code: "RI",
+		name: "Rhode Island"
+	},
+	SC: {
+		code: "SC",
+		name: "South Carolina"
+	},
+	SD: {
+		code: "SD",
+		name: "South Dakota"
+	},
+	TN: {
+		code: "TN",
+		name: "Tennessee"
+	},
+	TX: {
+		code: "TX",
+		name: "Texas"
+	},
+	UT: {
+		code: "UT",
+		name: "Utah"
+	},
+	VT: {
+		code: "VT",
+		name: "Vermont"
+	},
+	VA: {
+		code: "VA",
+		name: "Virginia"
+	},
+	WA: {
+		code: "WA",
+		name: "Washington"
+	},
+	WV: {
+		code: "WV",
+		name: "West Virginia"
+	},
+	WI: {
+		code: "WI",
+		name: "Wisconsin"
+	},
+	WY: {
+		code: "WY",
+		name: "Wyoming"
+	}
+};
+const usStateOptions = Object.values(usStates).map((state) => ({
+	value: state.code,
+	label: state.name
+}));
+
+//#endregion
+//#region src/shared/postalCode.ts
+const DEFAULT_POSTAL_CODE_MAX_LENGTH = 8;
+const POSTAL_CODE_MAX_LENGTH_BY_COUNTRY = {
+	US: 10,
+	BR: 9,
+	GB: 8,
+	UK: 8,
+	AR: 8,
+	CA: 7,
+	IL: 7,
+	CN: 6,
+	NG: 6,
+	DE: 5,
+	ES: 5,
+	FR: 5,
+	IT: 5,
+	KE: 5,
+	MX: 5
+};
+const POSTAL_CODE_FORMAT_ERROR_KEYS = new Set([
+	"verification.errors.zipCodeInvalidFormat",
+	"verification.errors.postalCodeInvalidFormat",
+	"verification.errors.invalidPostalCodeFixedLength",
+	"verification.errors.CAPostalCodeInvalidFormat",
+	"verification.errors.UKPostalCodeInvalidFormat",
+	"verification.errors.ARPostalCodeInvalidFormat"
+]);
+const FIXED_LENGTH_KEY = "verification.errors.invalidPostalCodeFixedLength";
+const FIXED_DIGIT_POSTAL_CODE_LENGTH = {
+	DE: 5,
+	ES: 5,
+	FR: 5,
+	IT: 5,
+	KE: 5,
+	MX: 5,
+	CN: 6,
+	NG: 6,
+	IL: 7
+};
+function getPostalCodeMaxLength(country) {
+	return POSTAL_CODE_MAX_LENGTH_BY_COUNTRY[country] ?? DEFAULT_POSTAL_CODE_MAX_LENGTH;
+}
+function getPostalCodeErrorKey(country) {
+	if (country in FIXED_DIGIT_POSTAL_CODE_LENGTH) return FIXED_LENGTH_KEY;
+	if (country === "CA") return "verification.errors.CAPostalCodeInvalidFormat";
+	if (country === "AR") return "verification.errors.ARPostalCodeInvalidFormat";
+	if (country === "GB" || country === "UK") return "verification.errors.UKPostalCodeInvalidFormat";
+	if (country === "US") return "verification.errors.zipCodeInvalidFormat";
+	return "verification.errors.postalCodeInvalidFormat";
+}
+const US_POSTAL_CODE_REGEX = /^(?:\d{5}|\d{9}|\d{5}-\d{4})$/;
+const BR_POSTAL_CODE_REGEX = /^(?:\d{5}|\d{8}|\d{5}-\d{3})$/;
+const CA_POSTAL_CODE_REGEX = /^[A-Za-z]\d[A-Za-z] \d[A-Za-z]\d$/;
+const UK_POSTAL_CODE_REGEX = /^(?:[A-Z]{2}\d|[A-Z]{2}\d{2}|[A-Z]\d|[A-Z]\d{2}|[A-Z]\d[A-Z]|[A-Z]{2}\d[A-Z]) \d[A-Z]{2}$/;
+const AR_POSTAL_CODE_REGEX = /^[A-Za-z]\d{4}[A-Za-z]{3}$/;
+const FIVE_DIGIT_REGEX = /^\d{5}$/;
+const SIX_DIGIT_REGEX = /^\d{6}$/;
+const IL_POSTAL_CODE_REGEX = /^\d{7}$/;
+/**
+* Validates a postal code by country.
+* Covers all countries used by eKYC and eKYB.
+*/
+function validatePostalCode(postalCode, country) {
+	if (!postalCode) return false;
+	switch (country) {
+		case "US": return US_POSTAL_CODE_REGEX.test(postalCode);
+		case "BR": return BR_POSTAL_CODE_REGEX.test(postalCode);
+		case "CA": return CA_POSTAL_CODE_REGEX.test(postalCode);
+		case "GB":
+		case "UK": return UK_POSTAL_CODE_REGEX.test(postalCode.toUpperCase());
+		case "AR": return AR_POSTAL_CODE_REGEX.test(postalCode.replace(/\s/g, "").toUpperCase());
+		case "IL": return IL_POSTAL_CODE_REGEX.test(postalCode);
+		case "CN":
+		case "NG": return SIX_DIGIT_REGEX.test(postalCode);
+		case "DE":
+		case "FR":
+		case "IT":
+		case "ES":
+		case "MX":
+		case "KE": return FIVE_DIGIT_REGEX.test(postalCode);
+		case "CM": return postalCode.length > 0;
+		default: {
+			const stripped = postalCode.replace(/\D/g, "");
+			return /^\d+$/.test(stripped) && [5, DEFAULT_POSTAL_CODE_MAX_LENGTH].includes(stripped.length);
+		}
+	}
+}
+/**
+* Progressively formats postal code input by country.
+* Covers all countries used by eKYC and eKYB.
+*/
+function formatPostalCode(value, country) {
+	if (country === "US" || country === "BR") {
+		const maxDigits = country === "US" ? 9 : 8;
+		const hasDash = value.includes("-");
+		const digits = value.replace(/\D/g, "").slice(0, maxDigits);
+		if (digits.length <= 5) {
+			if (hasDash && digits.length === 5) return `${digits}-`;
+			return digits;
+		}
+		if (hasDash) return `${digits.slice(0, 5)}-${digits.slice(5)}`;
+		return digits;
+	}
+	if (country === "ES") return value.replace(/\D/g, "").slice(0, 5);
+	if (country === "CA") {
+		const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 6);
+		if (normalized.length <= 3) return normalized;
+		return `${normalized.slice(0, 3)} ${normalized.slice(3)}`;
+	}
+	if (country === "GB" || country === "UK") {
+		const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 7);
+		if (normalized.length <= 3) return normalized;
+		return `${normalized.slice(0, -3)} ${normalized.slice(-3)}`;
+	}
+	if (country === "AR") return value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 8);
+	if (country === "IL") return value.replace(/\D/g, "").slice(0, 7);
+	if (country === "CN" || country === "NG") return value.replace(/\D/g, "").slice(0, 6);
+	if (country === "DE" || country === "FR" || country === "IT" || country === "MX" || country === "KE") return value.replace(/\D/g, "").slice(0, 5);
+	return value.slice(0, DEFAULT_POSTAL_CODE_MAX_LENGTH);
+}
+
+//#endregion
+//#region src/shared/displayErrors.ts
+const DYNAMIC_REQUIRED_KEY = "verification.errors.fieldRequiredDynamic";
+
+//#endregion
+//#region src/shared/addressSuggestion.ts
+/**
+* Fills form values from an address autocomplete suggestion.
+* Shared between eKYC and eKYB address forms.
+*/
+function fillFromSuggestion(values, touched, suggestion) {
+	const newValues = { ...values };
+	const newTouched = { ...touched };
+	if (suggestion.street) {
+		newValues.street = suggestion.street;
+		newTouched.street = true;
+	}
+	if (suggestion.city) {
+		newValues.city = suggestion.city;
+		newTouched.city = true;
+	}
+	if (suggestion.stateCode) {
+		newValues.state = suggestion.stateCode;
+		newTouched.state = true;
+	}
+	if (suggestion.postalCode) {
+		newValues.postalCode = suggestion.postalCode;
+		newTouched.postalCode = true;
+	}
+	if (suggestion.houseNumber) {
+		newValues.houseNo = suggestion.houseNumber;
+		newTouched.houseNo = true;
+	}
+	return {
+		values: newValues,
+		touched: newTouched
+	};
+}
+
+//#endregion
+//#region src/shared/addressSearch.ts
+/** Searches for address suggestions via the address autocomplete API. */
+async function searchAddress(query, signal) {
+	const res = await api.post(endpoints.addressAutocomplete, { search: query }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addressAutocomplete} failed: ${res.status} ${res.statusText}`);
+	return { apiResponse: { items: (res.data.apiResponse?.items ?? []).map((item, i) => {
+		const addr = item.address ?? item;
+		return {
+			id: item.id ?? i,
+			label: addr.label ?? item.title ?? "",
+			street: addr.street,
+			city: addr.city,
+			stateCode: addr.stateCode ?? addr.state,
+			postalCode: addr.postalCode,
+			houseNumber: addr.houseNumber,
+			countryCode: addr.countryCode
+		};
+	}) } };
+}
+const DEBOUNCE_MS = 300;
+/**
+* XState callback actor that debounces address search requests.
+* Cancels in-flight HTTP requests when the actor is stopped.
+*/
+const debounceSearchActor = fromCallback(({ input, sendBack }) => {
+	const timerProvider = BrowserTimerProvider.getInstance();
+	const controller = new AbortController();
+	const handle = timerProvider.setTimeout(async () => {
+		try {
+			sendBack({
+				type: "RESULTS",
+				suggestions: (await searchAddress(input.query, controller.signal)).apiResponse?.items ?? []
+			});
+		} catch {
+			if (!controller.signal.aborted) sendBack({
+				type: "RESULTS",
+				suggestions: []
+			});
+		}
+	}, DEBOUNCE_MS);
+	return () => {
+		timerProvider.clearTimeout(handle);
+		controller.abort();
+	};
+});
+
+//#endregion
+export { POSTAL_CODE_FORMAT_ERROR_KEYS as a, getPostalCodeMaxLength as c, FIXED_DIGIT_POSTAL_CODE_LENGTH as i, validatePostalCode as l, fillFromSuggestion as n, formatPostalCode as o, DYNAMIC_REQUIRED_KEY as r, getPostalCodeErrorKey as s, debounceSearchActor as t, usStateOptions as u };

package/dist/authentication.d.ts

@@ -1,79 +1,11 @@
-import "./types-B4KNFqC4.js";
-import "./warmup-Da5qDIWZ.js";
-import { a as FaceCaptureDependencies, n as FaceCaptureManagerState, r as BaseFaceCaptureConfig, t as FaceCaptureManager } from "./faceCaptureManagerFactory-D1NUo68Z.js";
-import { t as Manager } from "./Manager-CG5CQ1kY.js";
-import "./camera-D7zu0Mls.js";
-import { t as ActorRefFrom } from "./Actor-B6Lr-x6S.js";
-import { t as AnyStateMachine } from "./StateMachine-WHeQE3lC.js";
-import "./types-DnrAr9fb.js";
-import { r as FlowModuleConfig } from "./types-Bn54lmeM.js";
-
-//#region src/modules/authentication/authenticationStateMachine.d.ts
-declare const _authenticationMachine: AnyStateMachine;
-type AuthenticationMachine = typeof _authenticationMachine;
-declare const authenticationMachine: AnyStateMachine;
-//#endregion
-//#region src/modules/authentication/types.d.ts
-type AuthenticationConfig = FlowModuleConfig['AUTHENTICATION'] & BaseFaceCaptureConfig;
-//#endregion
-//#region src/modules/authentication/authenticationActor.d.ts
-type CreateAuthenticationActorOptions = {
-  config: AuthenticationConfig;
-  dependencies?: FaceCaptureDependencies;
-  authHint?: string;
-};
-type AuthenticationActor = ActorRefFrom<AuthenticationMachine>;
-declare function createAuthenticationActor(options: CreateAuthenticationActorOptions): AuthenticationActor;
-//#endregion
-//#region src/modules/authentication/authenticationManager.d.ts
-type AuthenticationState = FaceCaptureManagerState;
-/**
- * Creates an authentication manager instance for handling face authentication flow.
- *
- * The authentication manager provides:
- * - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
- * - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
- * - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
- * - Camera stream access when in `capture` state
- * - Detection status feedback during face detection
- * - Attempt tracking with `attemptsRemaining`
- *
- * @param options - Configuration for the authentication actor
- * @param options.config - The authentication module configuration from the flow
- * @param options.authHint - Hint for identifying the user (e.g., phone number, email)
- * @returns A manager instance with state subscription, API methods, and lifecycle controls
- *
- * @example
- * ```ts
- * const authManager = createAuthenticationManager({
- *   config: authConfig,
- *   authHint: 'user@example.com'
- * });
- *
- * authManager.subscribe((state) => {
- *   if (state.status === 'capture') {
- *     console.log('Camera ready:', state.stream);
- *     console.log('Detection status:', state.detectionStatus);
- *   }
- *   if (state.status === 'finished') {
- *     console.log('Authentication successful!');
- *   }
- * });
- *
- * authManager.load();
- * ```
- */
-declare function createAuthenticationManager(options: CreateAuthenticationActorOptions): Manager<FaceCaptureManagerState> & {
-  load(): void;
-  nextStep(): void;
-  requestPermission(): void;
-  goToLearnMore(): void;
-  back(): void;
-  close(): void;
-  reset(): void;
-  retryCapture(): void;
-  capture(): void;
-};
-type AuthenticationManager = FaceCaptureManager;
-//#endregion
+import "./deepsightService-CP5OM4Fc.js";
+import { g as AuthenticationConfig, h as createAuthenticationActor, m as CreateAuthenticationActorOptions, p as AuthenticationActor, y as authenticationMachine } from "./faceCaptureManagerFactory-Dm3dO_r0.js";
+import "./warmup-4e5k___O.js";
+import "./Manager-DsNvecSe.js";
+import "./camera-Bzi6CMAW.js";
+import "./Actor-D3GOC38V.js";
+import "./StateMachine-BFurBmbZ.js";
+import "./types-BHnsBsl_.js";
+import "./types-seztsdvN.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-BWtUIJXV.js";
 export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };