@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/clientLifecycle-Ct7h9uxx.esm.js

@@ -0,0 +1,534 @@
+import { a as WasmWebClientError, c as setWebApiHttpTransport, l as setupWasmConnection, o as executeWasmRequest, s as initializeWasmWebClient } from "./WasmUtilProvider-ADG54T6M.esm.js";
+import { o as setClient } from "./api-DsbUi7TO.esm.js";
+
+//#region ../infra/src/http/createApi.ts
+var FetchHttpError = class extends Error {
+	constructor(status, statusText, url, method, headers, data) {
+		super(`HTTP ${status} ${statusText}`);
+		this.ok = false;
+		this.status = status;
+		this.statusText = statusText;
+		this.url = url;
+		this.method = method;
+		this.headers = headers;
+		this.data = data;
+		this.name = "FetchHttpError";
+	}
+};
+const buildQueryString$1 = (query) => {
+	if (!query) return "";
+	const params = new URLSearchParams();
+	Object.entries(query).forEach(([key, value]) => {
+		if (value !== void 0 && value !== null) params.append(key, String(value));
+	});
+	const str = params.toString();
+	return str ? `?${str}` : "";
+};
+const buildUrl$1 = (baseURL, url, query) => {
+	const queryString = buildQueryString$1(query);
+	if (url.startsWith("http://") || url.startsWith("https://")) return `${url}${queryString}`;
+	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${url.startsWith("/") ? url : `/${url}`}${queryString}`;
+};
+const prepareBody$1 = (body) => {
+	if (body === null || body === void 0) return null;
+	if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer) return body;
+	if (typeof body === "object") return JSON.stringify(body);
+	return String(body);
+};
+const parseResponse = async (response, parseType) => {
+	if (parseType === "response") return response;
+	if (parseType === "blob") return await response.blob();
+	if (parseType === "arrayBuffer") return await response.arrayBuffer();
+	if (parseType === "text") return await response.text();
+	const contentType = response.headers.get("content-type") ?? "";
+	if (parseType === "json" || contentType.includes("application/json")) {
+		const raw = await response.text();
+		if (raw.length === 0) return "";
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return raw;
+		}
+	}
+	return await response.text();
+};
+const DEFAULT_TIMEOUT$1 = 3e4;
+const requestWithXHR = (fullUrl, method, mergedHeaders, requestBody, timeout, signal, onUploadProgress) => {
+	return new Promise((resolve, reject) => {
+		const xhr = new XMLHttpRequest();
+		xhr.open(method, fullUrl, true);
+		Object.entries(mergedHeaders).forEach(([key, value]) => {
+			xhr.setRequestHeader(key, value);
+		});
+		xhr.timeout = timeout;
+		xhr.upload.onprogress = (event) => {
+			if (event.lengthComputable) {
+				const percentComplete = event.loaded / event.total * 100;
+				onUploadProgress(Math.round(percentComplete));
+			}
+		};
+		xhr.onload = () => {
+			const responseHeaders = {};
+			xhr.getAllResponseHeaders().split("\r\n").forEach((line) => {
+				const parts = line.split(": ");
+				if (parts.length === 2) responseHeaders[parts[0].toLowerCase()] = parts[1];
+			});
+			let data;
+			try {
+				if ((xhr.getResponseHeader("content-type") ?? "").includes("application/json")) data = JSON.parse(xhr.responseText);
+				else data = xhr.responseText;
+			} catch {
+				data = xhr.responseText;
+			}
+			if (xhr.status >= 200 && xhr.status < 300) resolve({
+				ok: true,
+				status: xhr.status,
+				statusText: xhr.statusText,
+				url: fullUrl,
+				headers: responseHeaders,
+				data
+			});
+			else reject(new FetchHttpError(xhr.status, xhr.statusText, fullUrl, method, responseHeaders, data));
+		};
+		xhr.onerror = () => {
+			reject(new FetchHttpError(0, "Network Error", fullUrl, method, {}, null));
+		};
+		xhr.ontimeout = () => {
+			reject(new FetchHttpError(0, "Request timeout", fullUrl, method, {}, null));
+		};
+		if (signal) signal.addEventListener("abort", () => {
+			xhr.abort();
+			reject(new FetchHttpError(0, "Request aborted", fullUrl, method, {}, null));
+		});
+		xhr.send(requestBody);
+	});
+};
+const createApi = (config) => {
+	const headers = {
+		"Content-Type": "application/json",
+		Accept: "application/json",
+		"api-version": "1.0",
+		...config.customHeaders ?? {}
+	};
+	const defaults = {
+		baseURL: config.apiURL,
+		headers
+	};
+	const client = {
+		defaults,
+		async request(requestConfig) {
+			const { method = "GET", url, headers: headers$1 = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT$1, parse, onUploadProgress, keepalive } = requestConfig;
+			const fullUrl = buildUrl$1(defaults.baseURL, url, params ?? query);
+			const mergedHeaders = {
+				...defaults.headers,
+				...headers$1
+			};
+			const requestBody = prepareBody$1(body);
+			let finalHeaders = mergedHeaders;
+			if (requestBody === null && (method === "POST" || method === "PUT" || method === "PATCH")) {
+				const { "Content-Type": _, ...headersWithoutContentType } = mergedHeaders;
+				finalHeaders = headersWithoutContentType;
+			}
+			if (onUploadProgress) {
+				if (requestBody !== null && typeof ReadableStream !== "undefined" && requestBody instanceof ReadableStream) throw new Error("Upload progress tracking is not supported for ReadableStream bodies");
+				return requestWithXHR(fullUrl, method, finalHeaders, requestBody, timeout, signal, onUploadProgress);
+			}
+			const controller = new AbortController();
+			const abortSignal = signal ?? controller.signal;
+			const timeoutId = setTimeout(() => controller.abort(), timeout);
+			try {
+				const response = await fetch(fullUrl, {
+					method,
+					headers: finalHeaders,
+					body: requestBody,
+					signal: abortSignal,
+					keepalive
+				});
+				if (timeoutId) clearTimeout(timeoutId);
+				const responseHeaders = {};
+				response.headers.forEach((value, key) => {
+					responseHeaders[key] = value;
+				});
+				const data = await parseResponse(response, parse);
+				if (!response.ok) throw new FetchHttpError(response.status, response.statusText, fullUrl, method, responseHeaders, data);
+				return {
+					ok: true,
+					status: response.status,
+					statusText: response.statusText,
+					url: fullUrl,
+					headers: responseHeaders,
+					data
+				};
+			} catch (error) {
+				if (timeoutId) clearTimeout(timeoutId);
+				if (error instanceof FetchHttpError) throw error;
+				if (error instanceof Error && error.name === "AbortError") throw new FetchHttpError(0, "Request timeout", fullUrl, method, {}, null);
+				throw error;
+			}
+		},
+		get(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "GET"
+			});
+		},
+		post(url, body, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				body,
+				method: "POST"
+			});
+		},
+		put(url, body, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				body,
+				method: "PUT"
+			});
+		},
+		patch(url, body, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				body,
+				method: "PATCH"
+			});
+		},
+		delete(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "DELETE"
+			});
+		},
+		head(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "HEAD"
+			});
+		},
+		options(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "OPTIONS"
+			});
+		},
+		setHeader(name, value) {
+			defaults.headers[name] = value;
+		}
+	};
+	return client;
+};
+var createApi_default = createApi;
+
+//#endregion
+//#region ../infra/src/http/createWasmApi.ts
+const RSA_OAEP_SHA256_SCHEME = "RSA/NONE/OAEPWITHSHA-256ANDMGF1PADDING";
+/**
+* Builds the base set of HTTP headers that the WASM WebClient sends on every
+* request (including the internal `/e2ee/key/v2` and `/e2ee/key` handshake
+* calls).
+*/
+function buildWasmDefaultHeaders(customHeaders) {
+	return {
+		"Content-Type": "application/json",
+		Accept: "application/json",
+		"api-version": "1.0",
+		...customHeaders ?? {}
+	};
+}
+var WasmHttpError = class extends Error {
+	constructor(status, statusText, url, method, headers, data) {
+		super(`HTTP ${status} ${statusText}`);
+		this.ok = false;
+		this.status = status;
+		this.statusText = statusText;
+		this.url = url;
+		this.method = method;
+		this.headers = headers;
+		this.data = data;
+		this.name = "WasmHttpError";
+	}
+};
+const DEFAULT_TIMEOUT = 3e4;
+const HTTP_METHODS = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]);
+const buildQueryString = (query) => {
+	if (!query) return "";
+	const params = new URLSearchParams();
+	Object.entries(query).forEach(([key, value]) => {
+		if (value !== void 0 && value !== null) params.append(key, String(value));
+	});
+	const str = params.toString();
+	return str ? `?${str}` : "";
+};
+const buildUrl = (baseURL, url, query) => {
+	const queryString = buildQueryString(query);
+	if (url.startsWith("http://") || url.startsWith("https://")) return `${url}${queryString}`;
+	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${url.startsWith("/") ? url : `/${url}`}${queryString}`;
+};
+const prepareBody = (body) => {
+	if (body === null || body === void 0) return void 0;
+	if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || body instanceof Uint8Array || typeof body === "string") return body;
+	if (typeof body === "object") return body;
+	return String(body);
+};
+const normalizeMethod = (method) => {
+	const upper = method.toUpperCase();
+	if (!HTTP_METHODS.has(upper)) throw new Error(`Unsupported HTTP method for WASM client: ${method}`);
+	return upper;
+};
+const getErrorStatus = (error) => {
+	if (error instanceof WasmWebClientError) return error.statusCode;
+	if (typeof error === "object" && error !== null) {
+		const record = error;
+		if (typeof record.statusCode === "number") return record.statusCode;
+		if (typeof record.status === "number") return record.status;
+	}
+	return 0;
+};
+const getErrorData = (error) => {
+	if (error instanceof WasmWebClientError) return error.response?.data ?? null;
+	return null;
+};
+const getErrorMessage = (error) => {
+	if (error instanceof Error) return error.message;
+	return "WasmWebClient request failed";
+};
+const withAbortSignal = async (promise, signal, error) => {
+	if (!signal) return await promise;
+	if (signal.aborted) throw error;
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => reject(error);
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", onAbort);
+		});
+	});
+};
+const createWasmApi = async (config) => {
+	const headers = buildWasmDefaultHeaders(config.customHeaders);
+	const isEncryptionEnabled = config.isEncryptionEnabled ?? (() => false);
+	const useSha256 = config.mgf1 === "sha256";
+	await initializeWasmWebClient(config.wasm.wasmPath, config.wasm.wasmSimdPath ?? config.wasm.wasmPath, config.wasm.glueCodePath, config.wasm.glueCodeSimdPath ?? "", config.wasm.useSimd ?? true);
+	await setupWasmConnection(config.apiURL, "", config.encryptionEnabled ?? false, headers, useSha256);
+	const defaults = {
+		baseURL: config.apiURL,
+		headers
+	};
+	const client = {
+		defaults,
+		async request(requestConfig) {
+			const { method = "GET", url, headers: requestHeaders = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT, onUploadProgress, ie = false } = requestConfig;
+			const upperMethod = normalizeMethod(method);
+			const requestParams = params ?? query;
+			const fullUrl = buildUrl(defaults.baseURL, url, requestParams);
+			const needsSchemeHeader = ie || useSha256 && isEncryptionEnabled();
+			const mergedHeaders = {
+				...defaults.headers,
+				...needsSchemeHeader ? { "X-RSA-Encryption-Scheme": RSA_OAEP_SHA256_SCHEME } : {},
+				...requestHeaders
+			};
+			const requestBody = prepareBody(body);
+			const wasmProgress = onUploadProgress ? (progress) => {
+				if (progress.total > 0) onUploadProgress(Math.round(progress.loaded / progress.total * 100));
+			} : void 0;
+			const abortError = new WasmHttpError(0, "Request aborted", fullUrl, upperMethod, {}, null);
+			if (signal?.aborted) throw abortError;
+			try {
+				const response = await withAbortSignal(executeWasmRequest(upperMethod, url, requestBody, mergedHeaders, requestParams, timeout, wasmProgress, ie), signal, abortError);
+				if (response.status < 200 || response.status >= 300) throw new WasmHttpError(response.status, "", fullUrl, upperMethod, {}, response.data);
+				return {
+					ok: true,
+					status: response.status,
+					statusText: "",
+					url: fullUrl,
+					headers: {},
+					data: response.data
+				};
+			} catch (error) {
+				if (error instanceof WasmHttpError) throw error;
+				throw new WasmHttpError(getErrorStatus(error), getErrorMessage(error), fullUrl, upperMethod, {}, getErrorData(error));
+			}
+		},
+		get(url, requestConfig) {
+			return client.request({
+				...requestConfig,
+				url,
+				method: "GET"
+			});
+		},
+		post(url, body, requestConfig) {
+			return client.request({
+				...requestConfig,
+				url,
+				body,
+				method: "POST"
+			});
+		},
+		put(url, body, requestConfig) {
+			return client.request({
+				...requestConfig,
+				url,
+				body,
+				method: "PUT"
+			});
+		},
+		patch(url, body, requestConfig) {
+			return client.request({
+				...requestConfig,
+				url,
+				body,
+				method: "PATCH"
+			});
+		},
+		delete(url, requestConfig) {
+			return client.request({
+				...requestConfig,
+				url,
+				method: "DELETE"
+			});
+		},
+		head() {
+			return Promise.reject(/* @__PURE__ */ new Error("HEAD is not supported by the WASM HTTP client"));
+		},
+		options() {
+			return Promise.reject(/* @__PURE__ */ new Error("OPTIONS is not supported by the WASM HTTP client"));
+		},
+		setHeader(name, value) {
+			defaults.headers[name] = value;
+		}
+	};
+	return client;
+};
+var createWasmApi_default = createWasmApi;
+
+//#endregion
+//#region src/internal/http/clientLifecycle.ts
+/**
+* Wraps the active HttpClient as a transport for the C++ `WebApi` host
+* adapter. Lets the on-device face-results POST flow through the same
+* `httpClient.request()` pipeline as every other endpoint — header
+* injection, encryption-state handling, default headers, timeout — instead
+* of bypassing it via `executeWasmRequest` directly.
+*/
+function bindWebApiTransport(client) {
+	return async (url, body, config) => {
+		const response = await client.request({
+			method: "POST",
+			url,
+			body,
+			headers: config.headers,
+			params: config.params,
+			timeout: config.timeout,
+			ie: config.ie
+		});
+		return {
+			data: response.data,
+			status: response.status
+		};
+	};
+}
+function installClient(client) {
+	setClient(client);
+	setWebApiHttpTransport(bindWebApiTransport(client));
+}
+let storedHttpConfig;
+/** Reads the current HTTP-client config (or `undefined` if none installed). */
+function getStoredHttpConfig() {
+	return storedHttpConfig;
+}
+/** Whether encryption is currently active on the installed HTTP client. */
+function isHttpEncrypted() {
+	return storedHttpConfig?.encryption.enabled ?? false;
+}
+/** Clears all HTTP-client state. Called by `reset()`. */
+function resetHttpClientState() {
+	storedHttpConfig = void 0;
+	setWebApiHttpTransport(null);
+}
+/**
+* Builds (or replaces) the HTTP client when `setup()` receives an `apiURL`.
+* Picks `createWasmApi` when `effectiveWasm` is set, otherwise plain
+* `createApi`. Wraps the call in handshake-failure context when encryption
+* is requested.
+*/
+async function installFreshHttpClient(apiURL, options, effectiveWasm, encryption) {
+	installClient(effectiveWasm ? await withHandshakeFailureContext(encryption.enabled, () => createWasmApi_default({
+		apiURL,
+		customHeaders: options.customHeaders,
+		timeout: options.timeout,
+		wasm: effectiveWasm,
+		encryptionEnabled: encryption.enabled,
+		mgf1: encryption.mgf1,
+		isEncryptionEnabled: isHttpEncrypted
+	})) : createApi_default({
+		apiURL,
+		customHeaders: options.customHeaders,
+		timeout: options.timeout
+	}));
+	storedHttpConfig = {
+		apiURL,
+		customHeaders: options.customHeaders,
+		timeout: options.timeout,
+		isWasm: Boolean(effectiveWasm),
+		encryption
+	};
+}
+/**
+* Replaces the active HTTP client with the WASM-backed one. Used internally
+* by lazy-loading UI components (`<incode-flow>`, `<incode-workflow>`) when
+* WASM finishes warming up.
+*
+* No-op when no apiURL was previously configured, or when the active client
+* is already WASM-backed. The encryption state (enabled + MGF1 scheme) is
+* preserved across the swap — this is *not* a user-facing encryption change.
+*
+* @internal NOT a public API. Application code should use
+*   `setup({ wasm: {...} })` instead.
+*/
+async function upgradeToWasmHttpClient(resolved) {
+	const stored = storedHttpConfig;
+	if (!stored || stored.isWasm) return;
+	installClient(await createWasmApi_default({
+		apiURL: stored.apiURL,
+		customHeaders: stored.customHeaders,
+		timeout: stored.timeout,
+		wasm: resolved,
+		encryptionEnabled: stored.encryption.enabled,
+		mgf1: stored.encryption.mgf1,
+		isEncryptionEnabled: isHttpEncrypted
+	}));
+	storedHttpConfig = {
+		...stored,
+		isWasm: true
+	};
+}
+/**
+* When `wantsEncryption` is true, wraps a call that triggers the in-binary
+* RSA/AES handshake so its rejection surfaces as a single, descriptive error
+* with the original error preserved as `cause`. Pass-through otherwise.
+*/
+async function withHandshakeFailureContext(wantsEncryption, fn) {
+	if (!wantsEncryption) return fn();
+	try {
+		return await fn();
+	} catch (cause) {
+		const error = /* @__PURE__ */ new Error("Failed to establish encrypted transport. The /e2ee/key handshake did not complete. Verify the apiURL is reachable and that the environment supports E2EE.");
+		error.cause = cause;
+		throw error;
+	}
+}
+
+//#endregion
+export { createApi_default as a, upgradeToWasmHttpClient as i, installFreshHttpClient as n, resetHttpClientState as r, getStoredHttpConfig as t };

package/dist/consent.d.ts

@@ -1,4 +1,5 @@
-import "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-Cg5Sk2tv.js";
+import "./StateMachine-C_AY4cs7.js";
+import "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-DufVo9D9.js";
 export { type ConsentActor, type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/consent.esm.js

@@ -1,8 +1,9 @@
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import { t as consentMachine } from "./consentStateMachine-BG3yL8aC.esm.js";
-import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BYo9Nu1r.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import { t as consentMachine } from "./consentStateMachine-DO2JqoZW.esm.js";
+import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BtnPZUW4.esm.js";
 
 export { consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/{consentManager-BYo9Nu1r.esm.js → consentManager-BtnPZUW4.esm.js}

@@ -1,6 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
-import { t as consentMachine } from "./consentStateMachine-BG3yL8aC.esm.js";
+import { n as createManagerInstrumentation, t as topLevelStateName } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as consentMachine } from "./consentStateMachine-DO2JqoZW.esm.js";
 
 //#region src/modules/consent/consentActor.ts
 function createConsentActor(options) {
@@ -12,6 +13,30 @@ function createConsentActor(options) {
 function getCanSubmit(checkboxes) {
 	return checkboxes.filter((checkbox) => checkbox.required).every((checkbox) => checkbox.checked);
 }
+/**
+* Maps a Consent (combined / data-sharing) state-machine snapshot to the
+* exact Figma "Tracked Events" screen name. Source: Data Sharing Consent
+* Figma file (`https://www.figma.com/design/CO2SfrFrWis9fIUKHvLYyY/Data-Sharing-Consent---Latest-Design?node-id=29235-1822`).
+* Family is `datasharingconsent.*` with two sub-screens nested under
+* `content`.
+*
+* Discriminator: any required checkbox unchecked → `content.default`;
+* all required checkboxes checked → `content.accepted`. `submitting`
+* continues to surface as `.accepted` (the user is post-acceptance).
+*
+* `idle`, `loading`, `error`, and `finished` are intentionally unmapped —
+* the Figma canvas does not define discrete tracked-event screens for
+* them.
+*/
+function getConsentScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "display": return getCanSubmit(snapshot.context.checkboxes) ? "datasharingconsent.content.accepted" : "datasharingconsent.content.default";
+		case "submitting": return "datasharingconsent.content.accepted";
+		default: return;
+	}
+}
 function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
@@ -69,7 +94,7 @@ function createConsentManager(options) {
 		actor: createConsentActor(options),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent)
+		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent, { getEventScreenName: getConsentScreenName })
 	});
 }
 /**
@@ -82,7 +107,7 @@ function createConsentManagerFromActor(actor) {
 		actor,
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent)
+		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent, { getEventScreenName: getConsentScreenName })
 	});
 }