@adyen/kyc-components 4.23.0 → 4.24.0-beta.0

package/dist/AddressFields-BC3QHs2u.js

@@ -0,0 +1,468 @@
+try {
+	let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "e1bb85b4-62b4-4d52-bde3-34af8a7b6df7", e._sentryDebugIdIdentifier = "sentry-dbid-e1bb85b4-62b4-4d52-bde3-34af8a7b6df7");
+} catch (e) {}
+import { r as useTranslation } from "./translation-DbATp_35.js";
+import { t as Icon } from "./Icon-4XR6gZzk.js";
+import { n as httpGet, r as httpPost, s as useApiContext } from "./http-fdIO--pH.js";
+import { p as getMaxLengthByFieldAndCountry } from "./validatorUtils-D2O6AAZn.js";
+import { t as useAnalyticsContext } from "./useAnalyticsContext-gSnRnYgV.js";
+import { r as translateTranslatable } from "./utils-CYUYe54m.js";
+import { t as createFormUtils } from "./formUtils-DVDcdZsP.js";
+import { t as Field } from "./Field-DwDJQVSS.js";
+import { t as Select } from "./Select-phAxjMBQ.js";
+import { n as useDebouncedCallback } from "./debouncedInputEvent-Fwwp_K_-.js";
+import { n as CountryField } from "./CountryField-DT6-Jr_b.js";
+import { l as addressFields, n as getAddressSchemaLabelsByCountry, o as CONDENSED_ADDRESS_FIELDS, r as getKeyForField, s as COUNTRIES_WITH_HOUSE_NUMBER_FIRST, t as getAddressSchemaForCountry } from "./utils-BWumuCvl.js";
+import { n as StateField } from "./StateField-BpMwetvd.js";
+import { t as InputText } from "./InputText-CFDEmEtp.js";
+import { r as countrySpecificFormatters } from "./InputDate-Bq3Sb-ZW.js";
+import { t as capitalize } from "./getProps-DVqK7eRw.js";
+import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+import { useQuery } from "@tanstack/preact-query";
+//#region src/api/providersConfiguration/useProviderStatus.ts
+var getProvidersStatus = async (legalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/configurations/providers/status`
+	}, data);
+};
+/**
+* Asks the backend if 3rd party providers like Loqate and Onfido are available.
+*
+* Bank verification providers are not included, as these are handled by Open Banking.
+*/
+var useProviderStatus = (data, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["providersStatus", data],
+		queryFn: () => getProvidersStatus(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+//#region src/components/Shared/fields/RegistrationAndOperationalAddressFields/utils.ts
+var JP_ONLY_ADDRESS_FIELDS = [
+	"jaHaniStateOrProvince",
+	"jaHaniCity",
+	"jaHaniStreet",
+	"jaKanaStateOrProvince",
+	"jaKanaCity",
+	"street2FullWidth"
+];
+var ALL_ADDRESS_FIELDS = [...addressFields, ...JP_ONLY_ADDRESS_FIELDS];
+/**
+* Parses the nested trusted fields on a legal entity e.g. ['registrationAddress.address', 'registrationAddress.postalCode'],
+* rebuilding them into the flattened, prefixed fields for the addresses, e.g., `registrationAddress.address` -> `registrationAddressAddress`
+*
+* @param prefix - `registrationAddress` or `operationalAddress`
+* @param trustedFields - trustedFields on legal entity
+* @returns An array of the nested field keys that are trusted
+*/
+var getNestedTrustedFields = (prefix, trustedFields) => {
+	if (!trustedFields) return [];
+	const flattenedTrustedFields = [];
+	for (const trustedField of trustedFields) {
+		const [group, field] = trustedField.split(".");
+		if (group === prefix && field) flattenedTrustedFields.push(`${prefix}${capitalize(field)}`);
+	}
+	return flattenedTrustedFields;
+};
+/**
+* Flattens a nested address schema using the provided prefix to avoid collisions so each
+* field can be handled individually.
+*
+* `flattenAddressSchema('registrationAddress', { city: 'Chicago' })` -> `{ registrationAddressCity: 'Chicago' }`
+*/
+function flattenAddressSchema(prefix, address) {
+	const flattenedAddressSchema = {};
+	for (const field of ALL_ADDRESS_FIELDS) flattenedAddressSchema[`${prefix}${capitalize(field)}`] = address?.[field];
+	return flattenedAddressSchema;
+}
+/**
+* Nests a flattened address schema, removing the provided prefix from each field. Used for
+* utilities that still expect nested data.
+*
+* `flattenAddressSchema('registrationAddress', { registrationAddressCity: 'Chicago' })` -> `{ city: 'Chicago' }`
+*/
+function nestAddressSchema(prefix, flatData) {
+	const nestedAddressSchema = {};
+	for (const field of ALL_ADDRESS_FIELDS) nestedAddressSchema[field] = flatData?.[`${prefix}${capitalize(field)}`];
+	return nestedAddressSchema;
+}
+var getPrefixedAddressFieldNames = (prefix) => ALL_ADDRESS_FIELDS.map((field) => `${prefix}${capitalize(field)}`);
+//#endregion
+//#region src/api/address/useRetrieveAddress.ts
+var retrieveAddress = async (legalEntityId, baseUrl, addressId) => {
+	return httpGet({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/addresses/${addressId}`
+	});
+};
+/**
+* @param addressId
+* @param options additional options passed to Tanstack Query, eg; refetchInterval for polling
+*/
+var useRetrieveAddress = (addressId, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["retrieveAddress", addressId],
+		queryFn: () => retrieveAddress(rootLegalEntityId.value, baseUrl.value, addressId),
+		...options
+	});
+};
+//#endregion
+//#region src/api/address/useSearchAddress.ts
+var searchAddress = async (legalEntityId, baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `legalEntities/${legalEntityId}/addresses`
+	}, data);
+};
+/**
+* @param data
+* @param options additional options passed to Tanstack Query, eg; refetchInterval for polling
+*/
+var useSearchAddress = (data, options) => {
+	const { rootLegalEntityId, baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["searchAddress", data],
+		queryFn: () => searchAddress(rootLegalEntityId.value, baseUrl.value, data),
+		...options
+	});
+};
+//#endregion
+//#region src/components/Shared/forms/Address/SearchAddressItem.tsx
+var getFormattedText = (highlightItems, text) => {
+	const formattedText = [];
+	let lastHighlightIndex = 0;
+	if (highlightItems[0] === "") return [text];
+	highlightItems.forEach((highlightValue) => {
+		const highlightRange = highlightValue.split("-");
+		const highlightInit = parseInt(highlightRange[0]);
+		const highlightEnd = parseInt(highlightRange[1]);
+		if (lastHighlightIndex < highlightInit) {
+			const remain = text.substring(lastHighlightIndex, highlightInit);
+			formattedText.push(`${remain}`);
+		}
+		const boldText = text.substring(highlightInit, highlightEnd);
+		formattedText.push(/* @__PURE__ */ jsx("span", {
+			className: "adyen-kyc-dropdown-search-element__description--highlight",
+			children: boldText
+		}));
+		lastHighlightIndex = highlightEnd;
+	});
+	if (lastHighlightIndex < text.length) formattedText.push(`${text.substring(lastHighlightIndex)}`);
+	return formattedText;
+};
+var getHighlightedText = ({ text = "", highlight = "", description = "" }) => {
+	let formattedText = [];
+	if (highlight === "") if (description) formattedText.push(`${text}, ${description}`);
+	else formattedText.push(text);
+	else {
+		const highlightItems = highlight.split(";");
+		formattedText = getFormattedText(highlightItems[0].split(","), text);
+		if (highlightItems.length > 1) {
+			formattedText.push(`, `);
+			formattedText.push(/* @__PURE__ */ jsx(Fragment, { children: getFormattedText(highlightItems[1].split(","), description) }));
+		} else if (description) formattedText.push(`, ${description}`);
+	}
+	return formattedText;
+};
+var SearchAddressItem = (item) => {
+	const { t } = useTranslation("common");
+	const { addressAmount } = item;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+		className: "adyen-kyc-dropdown-search-element__description",
+		children: getHighlightedText(item)
+	}), addressAmount && /* @__PURE__ */ jsxs("div", {
+		className: "adyen-kyc-dropdown-search-element__addresses",
+		children: [
+			addressAmount,
+			" ",
+			/* @__PURE__ */ jsxs("span", {
+				className: "adyen-kyc-dropdown-search-element__addresses--text",
+				children: [" ", t(($) => $["addresses"])]
+			}),
+			/* @__PURE__ */ jsx(Icon, {
+				name: "arrow-right",
+				className: "adyen-kyc-dropdown-search-element__addresses--icon"
+			})
+		]
+	})] });
+};
+//#endregion
+//#region src/components/Shared/forms/Address/SearchAddress.tsx
+var SearchAddress = ({ addressText, country, labelKey, errorMessage, isValid, readOnly, optional, handleBlur, onAddressTextChange, onAutofillAddress }) => {
+	const { t } = useTranslation("common");
+	const userEvents = useAnalyticsContext();
+	const [textToSearch, setTextToSearch] = useState();
+	const [showSearchList, setShowSearchList] = useState(false);
+	const [selectedAddress, setSelectedAddress] = useState();
+	const [drilldownContainerId, setDrilldownContainerId] = useState();
+	const debouncedSetTextToSearch = useDebouncedCallback(setTextToSearch, 500);
+	const searchAddressQuery = useSearchAddress({
+		text: textToSearch,
+		country,
+		container: drilldownContainerId
+	}, { enabled: showSearchList && Boolean(textToSearch) && Boolean(country) });
+	const retrieveAddressQuery = useRetrieveAddress(selectedAddress?.id ?? "", { enabled: Boolean(selectedAddress) });
+	const results = useMemo(() => searchAddressQuery.data?.results?.map(formatAddressResult) ?? [], [searchAddressQuery.data?.results]);
+	useEffect(() => {
+		if (retrieveAddressQuery.data) {
+			userEvents.addPageEvent("Success", {
+				actionType: "select",
+				actionLevel: "field",
+				returnType: "backend",
+				returnValue: "retrieveAddress"
+			});
+			onAutofillAddress(retrieveAddressQuery.data);
+		}
+	}, [retrieveAddressQuery.data]);
+	const onSelectItem = useCallback((selected) => {
+		const selectedResult = results.find((i) => i.id === selected.id);
+		if (!selectedResult) return;
+		if (selectedResult.type === "Address") {
+			setSelectedAddress(selected);
+			setDrilldownContainerId(void 0);
+		} else {
+			setDrilldownContainerId(selectedResult.id);
+			setTextToSearch(`${selectedResult.text}`);
+			setTimeout(() => setShowSearchList(true));
+		}
+	}, [results]);
+	const items = useMemo(() => results.map((item) => ({
+		...item,
+		name: item.text
+	})), [results]);
+	return /* @__PURE__ */ jsx(Field, {
+		name: "address",
+		label: translateTranslatable(t, labelKey),
+		errorMessage,
+		isValid,
+		optional,
+		children: (childProps) => /* @__PURE__ */ jsx(Select, {
+			...childProps,
+			name: "address",
+			filterable: "prefiltered",
+			items,
+			selected: selectedAddress,
+			loading: searchAddressQuery.isLoading || retrieveAddressQuery.isLoading,
+			onSelect: onSelectItem,
+			getSearchItem: SearchAddressItem,
+			behaviour: "textIsData",
+			text: addressText,
+			setText: (text) => {
+				onAddressTextChange(text);
+				debouncedSetTextToSearch(text);
+			},
+			showList: showSearchList,
+			setShowList: setShowSearchList,
+			readonly: Boolean(readOnly),
+			placeholder: t(($) => $["address__placeHolder"]),
+			onBlur: handleBlur
+		})
+	});
+};
+var formatAddressResult = (item) => {
+	if (item.description.includes("Addresses")) {
+		const splitDescription = item.description.split(" - ");
+		if (splitDescription.length === 1) return {
+			...item,
+			description: "",
+			addressAmount: splitDescription[0].replace("Addresses", "")
+		};
+		return {
+			...item,
+			description: splitDescription[0],
+			addressAmount: splitDescription[1].replace("Addresses", "")
+		};
+	}
+	return item;
+};
+//#endregion
+//#region src/components/Shared/forms/Address/AddressField.tsx
+/**
+* USAGE: Specifically defined as a util to provide a wrapper for fields created within the Address component
+*
+* NOT TO BE USED: if you just want to add a Country or State dropdown outside of an Address component
+* - then you should implement <CountryField> or <StateField> directly
+*/
+function AddressField({ schema, data, valid, errors, fieldProblems, fieldName, trimOnBlur, hideField, maxlength, readOnly, optional, handleChangeFor, handleBlur }) {
+	const { t } = useTranslation("common");
+	const { data: providerStatus } = useProviderStatus({ providers: ["address"] });
+	const addressSearchEnabled = providerStatus?.statuses?.address?.enabled ?? false;
+	const formUtils = createFormUtils({ data }, t);
+	const errorMessage = formUtils.getErrorMessage(fieldName, errors ?? {}, fieldProblems);
+	const value = data[fieldName];
+	const labelKey = getKeyForField(fieldName, data.country);
+	const setAddressFieldFromFoundAddress = useCallback(({ houseNumberOrName, street, line1 }) => {
+		const hasHouseNumber = !!houseNumberOrName;
+		if (!street && line1) return handleChangeFor("street", "input")(line1);
+		if (hasHouseNumber) {
+			const formattedAddress = (data.country ? COUNTRIES_WITH_HOUSE_NUMBER_FIRST.includes(data.country) : false) ? `${houseNumberOrName} ${street}` : `${street} ${houseNumberOrName}`;
+			return handleChangeFor("street", "input")(formattedAddress);
+		}
+		return handleChangeFor("street", "input")(street);
+	}, [data.country, handleChangeFor]);
+	const onAutofillAddress = useCallback((foundAddress) => {
+		schema?.forEach((field) => {
+			switch (field) {
+				case "country":
+					handleChangeFor("country", "input")(foundAddress.country ?? " ");
+					break;
+				case "street":
+					setAddressFieldFromFoundAddress(foundAddress);
+					break;
+				case "street2":
+					handleChangeFor("street2", "blur")(foundAddress.street2 ?? " ");
+					break;
+				case "city":
+					handleChangeFor("city", "input")(foundAddress.city ?? " ");
+					break;
+				case "postalCode":
+					handleChangeFor("postalCode", "input")(foundAddress.postalCode ?? " ");
+					break;
+				case "stateOrProvince":
+					handleChangeFor("stateOrProvince", "input")(foundAddress.stateOrProvince ?? " ");
+					break;
+				default: break;
+			}
+		});
+	}, [
+		handleChangeFor,
+		schema,
+		setAddressFieldFromFoundAddress
+	]);
+	if (hideField) return null;
+	switch (fieldName) {
+		case "street": return addressSearchEnabled ? /* @__PURE__ */ jsx(SearchAddress, {
+			addressText: data.street,
+			country: data.country,
+			labelKey,
+			errorMessage,
+			isValid: valid?.street,
+			readOnly,
+			optional,
+			handleBlur: (e) => {
+				handleChangeFor("street", "blur")(data.street);
+				handleBlur?.(e);
+			},
+			onAddressTextChange: handleChangeFor("street", "input"),
+			onAutofillAddress
+		}) : /* @__PURE__ */ jsx(Field, {
+			name: fieldName,
+			label: t(($) => $[labelKey]),
+			errorMessage,
+			isValid: valid?.[fieldName],
+			optional,
+			children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+				...childProps,
+				name: fieldName,
+				value,
+				onInput: handleChangeFor(fieldName, "input"),
+				onBlur: (e) => {
+					handleChangeFor(fieldName, "blur")(e);
+					handleBlur?.(e);
+				},
+				maxLength: maxlength,
+				"aria-required": true,
+				"aria-invalid": !valid?.[fieldName],
+				trimOnBlur,
+				readonly: Boolean(readOnly)
+			})
+		});
+		case "country": return /* @__PURE__ */ jsx(CountryField, {
+			data: { country: value },
+			valid: { country: valid?.country },
+			errors: { country: errorMessage },
+			labels: { country: formUtils.getLabel(fieldName, labelKey) },
+			readonly: Boolean(readOnly),
+			handleChangeFor,
+			handleBlur
+		});
+		case "stateOrProvince": return /* @__PURE__ */ jsx(StateField, {
+			data: { stateOrProvince: value },
+			valid: { stateOrProvince: valid?.stateOrProvince },
+			errors: { stateOrProvince: errorMessage },
+			readonly: Boolean(readOnly),
+			selectedCountry: data.country,
+			handleChangeFor,
+			handleBlur
+		});
+		default: return /* @__PURE__ */ jsx(Field, {
+			name: fieldName,
+			label: t(($) => $[labelKey]),
+			errorMessage,
+			isValid: valid?.[fieldName],
+			optional,
+			children: (childProps) => /* @__PURE__ */ jsx(InputText, {
+				...childProps,
+				name: fieldName,
+				value: fieldName === "postalCode" ? value?.toUpperCase() : value,
+				onInput: handleChangeFor(fieldName, "input"),
+				onBlur: (e) => {
+					handleChangeFor(fieldName, "blur")(e);
+					handleBlur?.(e);
+				},
+				maxLength: maxlength,
+				"aria-required": true,
+				"aria-invalid": !valid?.[fieldName],
+				trimOnBlur,
+				readonly: Boolean(readOnly)
+			})
+		});
+	}
+}
+//#endregion
+//#region src/components/Shared/forms/Address/AddressFields.tsx
+var COUNTRIES_WITH_FORMATTED_ADDRESSES = ["US", "NL"];
+function AddressFields({ data = {}, readOnly, hideCountry, fieldValidationErrors, requiredFields, optionalFields = ["street2"], readOnlyFields, trustedFields, errors, valid, handleFieldChange, addressType }) {
+	const { t } = useTranslation("common");
+	const formUtils = createFormUtils({
+		data,
+		labels: getAddressSchemaLabelsByCountry(data.country),
+		readOnly,
+		requiredFields,
+		optionalFields,
+		readOnlyFields,
+		trustedFields
+	}, t);
+	const addressFields = getAddressSchemaForCountry(data.country).filter((fieldName) => formUtils.isRequiredField(fieldName) || formUtils.isOptionalField(fieldName));
+	const createField = (fieldName) => {
+		const hideField = hideCountry && fieldName === "country";
+		return /* @__PURE__ */ jsx(AddressField, {
+			schema: addressFields,
+			data,
+			valid: valid ?? {},
+			errors: errors ?? {},
+			fieldProblems: fieldValidationErrors,
+			fieldName,
+			maxlength: getMaxLengthByFieldAndCountry(countrySpecificFormatters, fieldName, data.country, true),
+			hideField,
+			readOnly: formUtils.isReadOnly(fieldName) || formUtils.isTrusted(fieldName),
+			optional: formUtils.isOptionalField(fieldName),
+			trimOnBlur: true,
+			handleChangeFor: handleFieldChange
+		}, fieldName);
+	};
+	if (data.country && COUNTRIES_WITH_FORMATTED_ADDRESSES.includes(data.country)) {
+		const condensedFields = CONDENSED_ADDRESS_FIELDS[data.country] ?? [];
+		switch (data.country) {
+			default: return /* @__PURE__ */ jsxs("fieldset", {
+				"aria-label": t(($) => $[addressType]),
+				children: [addressFields.filter((field) => !condensedFields.includes(field)).map((filteredField) => createField(filteredField)), condensedFields.length > 0 && /* @__PURE__ */ jsx("div", {
+					className: "adyen-kyc-address__condensed-fields",
+					children: condensedFields.map((field) => createField(field))
+				})]
+			});
+		}
+	}
+	return /* @__PURE__ */ jsx("fieldset", {
+		"aria-label": t(($) => $[addressType]),
+		children: addressFields.map((fieldName) => createField(fieldName))
+	});
+}
+//#endregion
+export { getPrefixedAddressFieldNames as a, getNestedTrustedFields as i, ALL_ADDRESS_FIELDS as n, nestAddressSchema as o, flattenAddressSchema as r, useProviderStatus as s, AddressFields as t };

package/dist/Alert-Cc7p0N5h.js

@@ -0,0 +1,172 @@
+try {
+	let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0e80757a-e0e4-4c24-aea2-a6a979be52f0", e._sentryDebugIdIdentifier = "sentry-dbid-0e80757a-e0e4-4c24-aea2-a6a979be52f0");
+} catch (e) {}
+import { r as useTranslation } from "./translation-DbATp_35.js";
+import { t as Icon } from "./Icon-4XR6gZzk.js";
+import { t as Typography } from "./Typography-CAc_f5Iq.js";
+import { t as Button } from "./Button-DPJ1k02w.js";
+import { t as Accordion } from "./Accordion-Dgdxfe-d.js";
+import { useState } from "preact/hooks";
+import cx from "classnames";
+import { jsx, jsxs } from "preact/jsx-runtime";
+import { isValidElement } from "preact";
+var alert_module_default = {
+	alert: "_alert_jgk1f_1",
+	"alert-without-icon": "_alert-without-icon_jgk1f_10",
+	alertWithoutIcon: "_alert-without-icon_jgk1f_10",
+	"alert-explanation": "_alert-explanation_jgk1f_10",
+	alertExplanation: "_alert-explanation_jgk1f_10",
+	"alert-actions": "_alert-actions_jgk1f_11",
+	alertActions: "_alert-actions_jgk1f_11",
+	"alert-basic": "_alert-basic_jgk1f_15",
+	alertBasic: "_alert-basic_jgk1f_15",
+	"alert-info": "_alert-info_jgk1f_19",
+	alertInfo: "_alert-info_jgk1f_19",
+	"alert-error": "_alert-error_jgk1f_23",
+	alertError: "_alert-error_jgk1f_23",
+	"alert-warning": "_alert-warning_jgk1f_27",
+	alertWarning: "_alert-warning_jgk1f_27",
+	"alert-success": "_alert-success_jgk1f_31",
+	alertSuccess: "_alert-success_jgk1f_31",
+	"alert-header": "_alert-header_jgk1f_35",
+	alertHeader: "_alert-header_jgk1f_35",
+	"alert-header-without-children": "_alert-header-without-children_jgk1f_40",
+	alertHeaderWithoutChildren: "_alert-header-without-children_jgk1f_40",
+	"alert-icon": "_alert-icon_jgk1f_44",
+	alertIcon: "_alert-icon_jgk1f_44",
+	"alert-icon-info": "_alert-icon-info_jgk1f_48",
+	alertIconInfo: "_alert-icon-info_jgk1f_48",
+	"alert-icon-error": "_alert-icon-error_jgk1f_52",
+	alertIconError: "_alert-icon-error_jgk1f_52",
+	"alert-icon-warning": "_alert-icon-warning_jgk1f_56",
+	alertIconWarning: "_alert-icon-warning_jgk1f_56",
+	"alert-icon-success": "_alert-icon-success_jgk1f_60",
+	alertIconSuccess: "_alert-icon-success_jgk1f_60",
+	"alert-title": "_alert-title_jgk1f_64",
+	alertTitle: "_alert-title_jgk1f_64"
+};
+//#endregion
+//#region src/components/ui/molecules/Alert/Alert.tsx
+var variantMap = {
+	basic: alert_module_default.alertBasic,
+	info: alert_module_default.alertInfo,
+	error: alert_module_default.alertError,
+	warning: alert_module_default.alertWarning,
+	success: alert_module_default.alertSuccess
+};
+var iconVariantMap = {
+	basic: "",
+	info: alert_module_default.alertIconInfo,
+	error: alert_module_default.alertIconError,
+	warning: alert_module_default.alertIconWarning,
+	success: alert_module_default.alertIconSuccess
+};
+var Alert = ({ title, variant = "basic", type = "default", className, actions, children, icon, testId, onClose, onToggle }) => {
+	const { t } = useTranslation("ui");
+	const [isClosed, setIsClosed] = useState(false);
+	if (isClosed) return null;
+	const closeAlert = () => {
+		if (onClose) onClose();
+		setIsClosed(true);
+	};
+	const renderIcon = () => {
+		if (icon === false) return void 0;
+		if (isValidElement(icon)) return icon;
+		return /* @__PURE__ */ jsx("span", {
+			className: cx(alert_module_default.alertIcon, iconVariantMap[variant]),
+			children: /* @__PURE__ */ jsx(AlertIcon, { variant })
+		});
+	};
+	const renderedIcon = renderIcon();
+	if (type === "collapsible") return /* @__PURE__ */ jsxs(Accordion, {
+		variant,
+		onToggle: onToggle || void 0,
+		narrow: true,
+		className,
+		children: [
+			/* @__PURE__ */ jsx("template", {
+				slot: "title",
+				children: title
+			}),
+			/* @__PURE__ */ jsx("template", {
+				slot: "icon",
+				children: renderedIcon
+			}),
+			/* @__PURE__ */ jsxs("template", {
+				slot: "content",
+				children: [children, !!actions && /* @__PURE__ */ jsx("div", {
+					className: alert_module_default.alertActions,
+					children: actions
+				})]
+			})
+		]
+	});
+	if (type === "callToAction") return /* @__PURE__ */ jsxs("div", {
+		className: cx(alert_module_default.alert, className, variantMap[variant], { [alert_module_default.alertWithoutIcon]: !renderedIcon }),
+		role: "alert",
+		"data-testid": testId,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: cx(alert_module_default.alertHeader, { [alert_module_default.alertHeaderWithoutChildren]: !children }),
+			children: [
+				renderedIcon,
+				title && /* @__PURE__ */ jsx(Typography, {
+					el: "h3",
+					variant: "body-strongest",
+					className: alert_module_default.alertTitle,
+					children: title
+				}),
+				!!actions && /* @__PURE__ */ jsx("div", {
+					className: alert_module_default.alertActions,
+					children: actions
+				})
+			]
+		}), !!children && /* @__PURE__ */ jsx("div", {
+			className: alert_module_default.alertExplanation,
+			children
+		})]
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: cx(alert_module_default.alert, className, variantMap[variant], { [alert_module_default.alertWithoutIcon]: !renderedIcon }),
+		role: "alert",
+		"data-testid": testId,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: alert_module_default.alertHeader,
+				children: [
+					renderedIcon,
+					title && /* @__PURE__ */ jsx(Typography, {
+						el: "h3",
+						variant: "body-strongest",
+						className: alert_module_default.alertTitle,
+						children: title
+					}),
+					type === "dismissible" && /* @__PURE__ */ jsx(Button, {
+						variant: "tertiary",
+						icon: "cross",
+						onClick: closeAlert,
+						children: t(($) => $["close"])
+					})
+				]
+			}),
+			!!children && /* @__PURE__ */ jsx("div", {
+				className: alert_module_default.alertExplanation,
+				children
+			}),
+			!!actions && /* @__PURE__ */ jsx("div", {
+				className: alert_module_default.alertActions,
+				children: actions
+			})
+		]
+	});
+};
+var AlertIcon = ({ variant }) => {
+	switch (variant) {
+		case "success": return /* @__PURE__ */ jsx(Icon, { name: "checkmark" });
+		case "error": return /* @__PURE__ */ jsx(Icon, { name: "error" });
+		case "warning": return /* @__PURE__ */ jsx(Icon, { name: "warning" });
+		default: return /* @__PURE__ */ jsx(Icon, { name: "info-circle-filled" });
+	}
+};
+//#endregion
+export { AlertIcon as n, Alert as t };

package/dist/AnalyticsContext-CpimDlw4.js

@@ -0,0 +1,21 @@
+try {
+	let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+	n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f8ecb0e2-f042-4cbc-8b84-7148e2f1bc8f", e._sentryDebugIdIdentifier = "sentry-dbid-f8ecb0e2-f042-4cbc-8b84-7148e2f1bc8f");
+} catch (e) {}
+import { i as noop } from "./genUtils-nphCwt1A.js";
+import { createContext } from "preact";
+var AnalyticsContext = createContext({
+	addEvent: noop,
+	addJourneyEvent: noop,
+	addTaskEvent: noop,
+	addPageEvent: noop,
+	addFieldEvent: noop,
+	startEvent: noop,
+	subscribe: noop,
+	trackExperiment: noop,
+	updateBaseTrackingPayload: noop,
+	updateSharedEventProperties: noop,
+	unsubscribe: noop
+});
+//#endregion
+export { AnalyticsContext as t };