@adyen/kyc-components 4.0.0-compact.4 → 4.0.0-compact.7

package/dist/useSetting-CbBaitp6.js

@@ -0,0 +1,19 @@
+;
+{
+  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] = "de47ac48-8414-465b-ab09-f1d7f86ac6b6", e._sentryDebugIdIdentifier = "sentry-dbid-de47ac48-8414-465b-ab09-f1d7f86ac6b6");
+  } catch (e) {
+  }
+}
+;
+import { useContext } from "preact/hooks";
+import { bi as SettingsContext } from "./StoreProvider-99-ewU62.js";
+const useSetting = (settingName) => {
+  const context = useContext(SettingsContext);
+  const { getSetting } = context;
+  return getSetting(settingName);
+};
+export {
+  useSetting as u
+};

package/dist/useTaskStatus-1OZ2clnm.js

@@ -0,0 +1,51 @@
+;
+{
+  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] = "5a276f79-b759-497c-8cf3-ad2cc267508b", e._sentryDebugIdIdentifier = "sentry-dbid-5a276f79-b759-497c-8cf3-ad2cc267508b");
+  } catch (e) {
+  }
+}
+;
+import { useQuery } from "@tanstack/preact-query";
+import { q as TaskStatuses, a3 as createLogger, b as useApiContext, k as httpGet } from "./StoreProvider-99-ewU62.js";
+const logger = createLogger();
+const normalizeTaskStatuses = (taskStatuses) => {
+  return taskStatuses?.statuses?.reduce((acc, currentTask) => {
+    const status = TaskStatuses[currentTask.status];
+    const statusEntries = currentTask.taskStatusEntries;
+    acc[currentTask.type] = {
+      status: status ?? TaskStatuses.DETAILS_REQUIRED,
+      taskStatusEntries: statusEntries
+    };
+    return acc;
+  }, {});
+};
+const getAccountTaskStatus = (accountId, payinPayoutTaskStatus) => {
+  const taskStatusEntries = payinPayoutTaskStatus?.taskStatusEntries;
+  const taskStatusEntry = taskStatusEntries?.find((entry) => entry.id.includes(accountId));
+  if (!taskStatusEntry) {
+    logger.warn(`No task status for this account: ${accountId}`);
+    return payinPayoutTaskStatus?.status ?? TaskStatuses.PROCESSING;
+  }
+  return TaskStatuses[taskStatusEntry.status];
+};
+const getTaskStatus = async (legalEntityId, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/taskStatus`
+  });
+};
+const useTaskStatus = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["taskStatus"],
+    queryFn: () => getTaskStatus(rootLegalEntityId.value, baseUrl.value),
+    select: (data) => normalizeTaskStatuses(data),
+    ...options
+  });
+};
+export {
+  getAccountTaskStatus as g,
+  useTaskStatus as u
+};

package/dist/{useTermsOfServiceStatus-BRdLkis6.js → useTermsOfServiceStatus-Dg_nBQgt.js}

@@ -2,12 +2,13 @@
 {
   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] = "10125311-8c5b-4f32-bb60-aad39256f7e9", e._sentryDebugIdIdentifier = "sentry-dbid-10125311-8c5b-4f32-bb60-aad39256f7e9");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "298db054-2f4b-43b7-80e0-248ea04d2cfb", e._sentryDebugIdIdentifier = "sentry-dbid-298db054-2f4b-43b7-80e0-248ea04d2cfb");
   } catch (e) {
   }
 }
 ;
-import { b as useApiContext, j as useQuery, m as httpGet } from "./StoreProvider-DTMSAVgy.js";
+import { useQuery } from "@tanstack/preact-query";
+import { b as useApiContext, k as httpGet } from "./StoreProvider-99-ewU62.js";
 const getTermsOfServiceAcceptanceInfos = async (legalEntityId, baseUrl) => {
   return httpGet({
     baseUrl,

package/dist/{useToastContext-BQYYaLd-.js → useToastContext-D643iewp.js}

@@ -2,13 +2,14 @@
 {
   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] = "171e517f-6393-42de-82c7-dbf112b5159c", e._sentryDebugIdIdentifier = "sentry-dbid-171e517f-6393-42de-82c7-dbf112b5159c");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "93315c4a-4b17-4721-917a-030c8d038173", e._sentryDebugIdIdentifier = "sentry-dbid-93315c4a-4b17-4721-917a-030c8d038173");
   } catch (e) {
   }
 }
 ;
-import { P as createLogger, a2 as useQueryClient, b as useApiContext, aW as ToastContext } from "./StoreProvider-DTMSAVgy.js";
-import { useCallback, useState, useContext } from "preact/hooks";
+import { useQueryClient } from "@tanstack/preact-query";
+import { useCallback, useContext } from "preact/hooks";
+import { a3 as createLogger, b as useApiContext, af as ToastContext } from "./StoreProvider-99-ewU62.js";
 const logger = createLogger();
 const QUERIES_TO_INVALIDATE_WHEN_ROOT_LE_IS_INVALIDATED = [
   "businessLines",
@@ -38,23 +39,11 @@ const useInvalidateRootLegalEntity = () => {
     [rootLegalEntityId.value, queryClient]
   );
 };
-function uuidv4() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    let r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-const useId = (prefix) => {
-  const [uuid] = useState(uuidv4());
-  return `${prefix}_${uuid}`;
-};
 function useToastContext() {
   const context = useContext(ToastContext);
   return context;
 }
 export {
-  useToastContext as a,
-  useId as b,
-  useInvalidateRootLegalEntity as c,
-  uuidv4 as u
+  useInvalidateRootLegalEntity as a,
+  useToastContext as u
 };

package/dist/useTrustMembers-BTCDIu6B.js

@@ -0,0 +1,163 @@
+;
+{
+  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] = "e124822c-dbbd-43dc-8452-24d039eb8921", e._sentryDebugIdIdentifier = "sentry-dbid-e124822c-dbbd-43dc-8452-24d039eb8921");
+  } catch (e) {
+  }
+}
+;
+import { useMemo } from "preact/hooks";
+import { ae as getOwnEntityAssociations, bn as TrustMemberTypes, c as useLegalEntity, o as LegalEntityTypes, R as ROOT_LE, v as useExperimentsContext } from "./StoreProvider-99-ewU62.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-ETDoz1H2.js";
+import { skipToken } from "@tanstack/preact-query";
+import { g as getLegalEntityNameBasedOnType } from "./getName-CnZDw7kV.js";
+const useExemptSettlor = ({
+  trust
+}) => {
+  const matchingAssociation = useMemo(() => {
+    if (!trust) return void 0;
+    return getOwnEntityAssociations(trust).find(
+      (association) => association.type === TrustMemberTypes.SETTLOR && Boolean(association.settlorExemptionReason)
+    );
+  }, [trust]);
+  const { data } = useLegalEntity(matchingAssociation?.legalEntityId ?? skipToken);
+  return data;
+};
+const splitAtFirstOccurrence = (str, separator) => {
+  const firstOccurrence = str.indexOf(separator);
+  if (firstOccurrence === -1) return [str];
+  return [str.slice(0, firstOccurrence), str.slice(firstOccurrence + 1)];
+};
+const getTrustMemberOwnerId = (trustMemberId, entityAssociations) => entityAssociations.find((association) => association.associatorId === trustMemberId)?.legalEntityId;
+const getFallbackName = (exemptSettlorAssociation) => {
+  const [firstName, lastName] = splitAtFirstOccurrence(exemptSettlorAssociation.name ?? "", " ");
+  return {
+    firstName,
+    lastName
+  };
+};
+const convertEntityAssociationIntoTrustMember = (association, associations, exemptSettlorLE) => {
+  if (association.settlorExemptionReason) {
+    return {
+      trustMemberType: "exemptSettlor",
+      roles: [TrustMemberTypes.SETTLOR],
+      legalEntityType: association.entityType,
+      legalEntityId: association.legalEntityId,
+      settlorExemptionReason: association.settlorExemptionReason,
+      exemptSettlorName: association.entityType === LegalEntityTypes.INDIVIDUAL ? exemptSettlorLE?.individual?.name ?? getFallbackName(association) : void 0,
+      name: association.name
+    };
+  }
+  if (association.entityType === LegalEntityTypes.ORGANIZATION)
+    return {
+      trustMemberType: "company",
+      roles: [],
+      legalEntityType: LegalEntityTypes.ORGANIZATION,
+      legalEntityId: association.legalEntityId,
+      name: association.name,
+      ownerId: getTrustMemberOwnerId(association.legalEntityId, associations)
+    };
+  if (association.entityType === LegalEntityTypes.INDIVIDUAL)
+    return {
+      trustMemberType: "regular",
+      roles: [],
+      legalEntityType: LegalEntityTypes.INDIVIDUAL,
+      legalEntityId: association.legalEntityId,
+      name: association.name
+    };
+  throw new Error(`Not a valid trust member: ${JSON.stringify(association)}`);
+};
+const mapEntityAssociationsToTrustMembers = (trustEntityId, entityAssociations, exemptSettlorLE) => {
+  const mappedTrustMembers = entityAssociations.reduce(
+    (acc, entityAssociation) => {
+      if (!Object.values(TrustMemberTypes).includes(entityAssociation.type) || entityAssociation.associatorId !== trustEntityId || !entityAssociation.legalEntityId) {
+        return acc;
+      }
+      const trustMember = acc[entityAssociation.legalEntityId] ?? convertEntityAssociationIntoTrustMember(
+        entityAssociation,
+        entityAssociations,
+        exemptSettlorLE
+      );
+      const trustMemberType = entityAssociation.type;
+      acc[entityAssociation.legalEntityId] = {
+        ...trustMember,
+        roles: [.../* @__PURE__ */ new Set([...trustMember.roles, trustMemberType])]
+      };
+      return acc;
+    },
+    {}
+  );
+  return Object.values(mappedTrustMembers);
+};
+const mapRootLegalEntityToTrustMember = (rootLegalEntity) => ({
+  trustMemberType: "rootTrustee",
+  roles: [TrustMemberTypes.TRUSTEE],
+  legalEntityType: rootLegalEntity.type,
+  legalEntityId: rootLegalEntity.id,
+  name: getLegalEntityNameBasedOnType(rootLegalEntity)
+});
+const mapUndefinedBeneficiaryInfoToTrustMembers = (undefinedBeneficiaryInfo) => undefinedBeneficiaryInfo.map(({ reference, description }) => ({
+  trustMemberType: "undefinedBeneficiary",
+  roles: [TrustMemberTypes.UNDEFINED_BENEFICIARY],
+  reference,
+  description
+}));
+const getTrustMembers = (trustLE, rootLegalEntity, exemptSettlorLE) => [
+  mapRootLegalEntityToTrustMember(rootLegalEntity),
+  ...mapEntityAssociationsToTrustMembers(
+    trustLE.id,
+    trustLE.entityAssociations ?? [],
+    exemptSettlorLE
+  ),
+  ...mapUndefinedBeneficiaryInfoToTrustMembers(trustLE.trust?.undefinedBeneficiaryInfo ?? [])
+];
+const combineRootLegalEntityWithEntityAssociations = (rootLegalEntity, entityAssociations) => {
+  const allowedRolesForRootLegalEntity = [
+    TrustMemberTypes.SETTLOR,
+    TrustMemberTypes.PROTECTOR,
+    TrustMemberTypes.DEFINED_BENEFICIARY
+  ];
+  const roles = entityAssociations.map((entityAssociation) => entityAssociation.type).filter((role) => allowedRolesForRootLegalEntity.includes(role));
+  return {
+    trustMemberType: "rootTrustee",
+    roles: [...roles, TrustMemberTypes.TRUSTEE],
+    legalEntityType: rootLegalEntity.type,
+    legalEntityId: rootLegalEntity.id,
+    name: getLegalEntityNameBasedOnType(rootLegalEntity)
+  };
+};
+const getRootTrusteeTrustMembers = (trustLE, rootLegalEntity, exemptSettlorLE) => {
+  const entityAssociations = trustLE.entityAssociations ?? [];
+  const rootLegalEntityAssociations = entityAssociations.filter(
+    (a) => a.legalEntityId === rootLegalEntity.id
+  );
+  const nonRootLegalEntityAssociations = entityAssociations.filter(
+    (a) => a.legalEntityId !== rootLegalEntity.id
+  );
+  return [
+    combineRootLegalEntityWithEntityAssociations(rootLegalEntity, rootLegalEntityAssociations),
+    ...mapEntityAssociationsToTrustMembers(
+      trustLE.id,
+      nonRootLegalEntityAssociations ?? [],
+      exemptSettlorLE
+    ),
+    ...mapUndefinedBeneficiaryInfoToTrustMembers(trustLE.trust?.undefinedBeneficiaryInfo ?? [])
+  ];
+};
+function useTrustMembers() {
+  const { data: rootLegalEntity } = useLegalEntity(ROOT_LE);
+  const { data: trust } = useAssociatedLegalEntity(rootLegalEntity, LegalEntityTypes.TRUST);
+  const { isExperimentEnabled } = useExperimentsContext();
+  const exemptSettlor = useExemptSettlor({
+    trust
+  });
+  const allowMoreRolesForMainRootTrustee = isExperimentEnabled("AllowMoreRolesForMainRootTrustee");
+  return useMemo(() => {
+    if (!rootLegalEntity || !trust?.trust) return [];
+    return allowMoreRolesForMainRootTrustee ? getRootTrusteeTrustMembers(trust, rootLegalEntity, exemptSettlor) : getTrustMembers(trust, rootLegalEntity, exemptSettlor);
+  }, [rootLegalEntity, trust, exemptSettlor, allowMoreRolesForMainRootTrustee]);
+}
+export {
+  useTrustMembers as u
+};

package/dist/{useUnincorporatedPartnershipMembers-fl3LbBcx.js → useUnincorporatedPartnershipMembers-BM9dNg4i.js}

@@ -2,16 +2,16 @@
 {
   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] = "2f27f250-f0f7-456e-9699-c852f2ccbf77", e._sentryDebugIdIdentifier = "sentry-dbid-2f27f250-f0f7-456e-9699-c852f2ccbf77");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9aff9633-cf8a-4bf0-9330-d4fdaaedcecb", e._sentryDebugIdIdentifier = "sentry-dbid-9aff9633-cf8a-4bf0-9330-d4fdaaedcecb");
   } catch (e) {
   }
 }
 ;
 import { useMemo } from "preact/hooks";
-import { r as LegalEntityTypes, ag as getOwnEntityAssociations, c as useLegalEntity, R as ROOT_LE } from "./StoreProvider-DTMSAVgy.js";
-import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-CtNg5gYS.js";
-import { U as UnincorporatedPartnershipMemberTypes } from "./CountryField-BIYJvEAW.js";
-import { g as getLegalEntityNameBasedOnType } from "./getName-9MyzlDpt.js";
+import { o as LegalEntityTypes, ae as getOwnEntityAssociations, c as useLegalEntity, R as ROOT_LE } from "./StoreProvider-99-ewU62.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-ETDoz1H2.js";
+import { U as UnincorporatedPartnershipMemberTypes } from "./unincorporated-partnership-MeN1dp53.js";
+import { g as getLegalEntityNameBasedOnType } from "./getName-CnZDw7kV.js";
 const getMemberOwnerId = (memberId, entityAssociations) => entityAssociations.find((association) => association.associatorId === memberId)?.legalEntityId;
 const convertEntityAssociationIntoUnincorporatedPartnershipMember = (association) => {
   if (association.entityType === LegalEntityTypes.INDIVIDUAL || association.entityType === LegalEntityTypes.ORGANIZATION)

package/dist/useUpdateBusinessLines-BuW6Vnof.js

@@ -0,0 +1,339 @@
+;
+{
+  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] = "823b5d34-a39a-495f-a737-f4a6e6b3794e", e._sentryDebugIdIdentifier = "sentry-dbid-823b5d34-a39a-495f-a737-f4a6e6b3794e");
+  } catch (e) {
+  }
+}
+;
+import { useQuery, useMutation } from "@tanstack/preact-query";
+import { b as useApiContext, k as httpGet, ai as isEmpty, u as useTranslation, v as useExperimentsContext, t as IconButton, $ as httpPost } from "./StoreProvider-99-ewU62.js";
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+import { useRef, useMemo, useState, useEffect } from "preact/hooks";
+import { F as Field } from "./Field-Bs7wGDqk.js";
+import { L as List } from "./List-BAzyC6sw.js";
+import { S as Select } from "./Select-DaCJsYNl.js";
+import { signal } from "@preact/signals";
+const fetchIndustryCodes = async (legalEntityId, baseUrl, businessLineTypes2, locale) => {
+  const results = await Promise.all(
+    businessLineTypes2.map((businessLineType) => {
+      return httpGet({
+        baseUrl,
+        path: `legalEntities/${legalEntityId}/businessLines/${businessLineType}/industryCodes?locale=${locale}`
+      });
+    })
+  );
+  const deduped = [];
+  for (const result of results) {
+    for (const industryCodeDTO of result) {
+      const found = deduped.find((item) => item.code === industryCodeDTO.code);
+      if (!found) {
+        deduped.push(industryCodeDTO);
+      }
+    }
+  }
+  return deduped;
+};
+const useIndustryCodes = (businessLineTypes2, locale, options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["industryCodes", businessLineTypes2.join(","), locale],
+    queryFn: () => fetchIndustryCodes(rootLegalEntityId.value, baseUrl.value, businessLineTypes2, locale),
+    ...options
+  });
+};
+const industryCodeFieldValidation = () => ({
+  industryCodes: {
+    modes: ["blur"],
+    validate: (industryCode) => !isEmpty(industryCode),
+    errorMessage: "fieldIsRequired"
+  }
+});
+const industryCodeFieldMetadata = {
+  label: "industry",
+  validators: [
+    industryCodeFieldValidation().industryCodes
+  ]
+};
+const selectedBusinessLine = signal(void 0);
+const shouldSignNewPci = signal(false);
+const industryCodesContent = "adyen-kyc-industry-codes-content";
+const industryCodesSelection = "adyen-kyc-industry-codes-selection";
+const styles$1 = {
+  industryCodesContent,
+  industryCodesSelection
+};
+const mapSelectedCodes = (selectedCodes) => {
+  return selectedCodes && selectedCodes.length > 0 ? selectedCodes.map((i) => {
+    return {
+      value: i,
+      touched: !!i.id
+    };
+  }) : [{ value: { id: "", name: "" }, touched: false }];
+};
+function IndustryCodeField({
+  data,
+  valid,
+  errors,
+  labels,
+  readonly,
+  handleChangeFor,
+  guidanceText,
+  setErrors,
+  // need to manually set errors due to nested select components
+  setValid,
+  // need to manually set validation due to nested select components
+  businessLineTypes: businessLineTypes2,
+  single = false,
+  industryCodes,
+  existingBusinessLines
+}) {
+  const { t } = useTranslation("ui");
+  const industryCodesRef = useRef(null);
+  const { isExperimentEnabled } = useExperimentsContext();
+  const singleIndustryCode = single || !!selectedBusinessLine.value || // when editing a business line, only single dropdown should render
+  isExperimentEnabled("EnableLimitToSingleBusinessLine");
+  const allIndustryCodeSelectItems = useMemo(
+    () => industryCodes?.map((entry) => ({
+      id: entry.code,
+      name: `${entry.code} - ${entry.description}`
+    })) ?? [],
+    [industryCodes]
+  );
+  const selectableIndustryCodes = useMemo(() => {
+    if (!businessLineTypes2.includes("acquiring")) return allIndustryCodeSelectItems;
+    const selectedIds = data.industryCodes?.map((c) => c.id);
+    const existingIds = (existingBusinessLines ?? []).map((b) => b.industryCode);
+    return allIndustryCodeSelectItems.filter((item) => {
+      const isDuplicate = selectedIds?.includes(item.id) || existingIds?.includes(item.id);
+      return !isDuplicate;
+    });
+  }, [allIndustryCodeSelectItems, businessLineTypes2, data.industryCodes, existingBusinessLines]);
+  const selectedCodes = data.industryCodes;
+  const [items, setItems] = useState(mapSelectedCodes(selectedCodes));
+  useEffect(() => {
+    setItems(mapSelectedCodes(selectedCodes));
+  }, [selectedCodes]);
+  const updateIndustryCodes = (value) => {
+    handleChangeFor("industryCodes")(value);
+  };
+  const addIndustryCodeField = (e) => {
+    if (items[items.length - 1].value.id === "") {
+      handleIndustryCodeFocusOut(e, items.length - 1);
+      return;
+    }
+    const newItems = [...items, { value: { id: "", name: "" }, touched: false }];
+    setItems(newItems);
+    updateIndustryCodes(newItems.map((item) => item.value));
+  };
+  const removeField = (indexToRemove) => {
+    const newItems = items.filter((_, index) => index !== indexToRemove);
+    setItems(newItems);
+    updateIndustryCodes(newItems.map((item) => item.value));
+  };
+  const handleSelectIndustryCode = (indexToUpdate, selectedItem) => {
+    setItems((prevItems) => {
+      const newItems = [...prevItems];
+      newItems[indexToUpdate] = {
+        value: {
+          id: selectedItem.id,
+          name: selectedItem.name
+        },
+        touched: true
+      };
+      updateIndustryCodes(
+        newItems.map((item) => {
+          return {
+            id: item.value.id,
+            name: item.value.name
+          };
+        })
+      );
+      return newItems;
+    });
+  };
+  const handleIndustryCodeFocusOut = (e, index) => {
+    if (industryCodesRef.current && !industryCodesRef.current.contains(e.relatedTarget)) {
+      setItems((prevItems) => {
+        if (prevItems[index].value.id || prevItems[index].touched) {
+          return prevItems;
+        }
+        const newItems = [...prevItems];
+        newItems[index] = { ...newItems[index], touched: true };
+        const isGroupInvalid = newItems.some((item) => item.value.id === "");
+        if (isGroupInvalid) {
+          setErrors?.(
+            "industryCodes",
+            {
+              isValid: false,
+              errorMessage: "fieldIsRequired",
+              hasError: true
+            },
+            "industryCodesForm"
+          );
+          setValid?.("industryCodes", false, "industryCodesForm");
+        } else {
+          setErrors?.("industryCodes", null, "industryCodesForm");
+          setValid?.("industryCodes", true, "industryCodesForm");
+        }
+        return newItems;
+      });
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    Field,
+    {
+      name: "industryCodes",
+      label: labels?.industryCodes || t(($) => $["industry"]),
+      errorMessage: errors.industryCodes,
+      isValid: valid.industryCodes,
+      formatGuidance: guidanceText.industryCodes,
+      showErrorIcon: false,
+      children: (childProps) => /* @__PURE__ */ jsx(Wrapper, { single: singleIndustryCode, children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: styles$1.industryCodesContent,
+          ref: industryCodesRef,
+          "data-testid": "industryCode",
+          children: items.map((code, index) => {
+            const isInvalid = code.touched && code.value.id === "";
+            return /* @__PURE__ */ jsxs("div", { className: styles$1.industryCodesSelection, children: [
+              /* @__PURE__ */ jsx(
+                Select,
+                {
+                  ...childProps,
+                  id: `industryCodeSelection-${index}`,
+                  name: `industryCodeSelection-${index}`,
+                  selected: code.value,
+                  placeholder: t(($) => $["industryCode__placeholder"]),
+                  items: allIndustryCodeSelectItems,
+                  excludedValues: allIndustryCodeSelectItems.filter(
+                    (i) => !selectableIndustryCodes.includes(i)
+                  ),
+                  readonly: !!data.industryCodes && readonly || !!industryCodes && selectableIndustryCodes.length === 0,
+                  onSelect: (selectedItem) => handleSelectIndustryCode(index, selectedItem),
+                  isInvalid,
+                  onBlur: (e) => handleIndustryCodeFocusOut(e, index)
+                }
+              ),
+              !singleIndustryCode && /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    ariaLabel: t(($) => $["removeIndustryCode"]),
+                    variant: "tertiary",
+                    icon: "minusCircleFilled",
+                    circle: true,
+                    onClick: () => removeField(index),
+                    disabled: items.length === 1 || readonly
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    ariaLabel: t(($) => $["addIndustryCode"]),
+                    variant: "tertiary",
+                    icon: "plusCircleFilled",
+                    circle: true,
+                    onClick: addIndustryCodeField,
+                    disabled: readonly || code.value.id === "" || code.value.id !== "" && index !== items.length - 1 || selectableIndustryCodes.length === 0
+                  }
+                )
+              ] })
+            ] }, code.value.id);
+          })
+        }
+      ) })
+    }
+  );
+}
+function Wrapper({ single, children }) {
+  return single ? children : /* @__PURE__ */ jsx(List, { dividers: false, variant: "grouped-primary", children });
+}
+const salesChannelsWithWebData = ["eCommerce", "ecomMoto"];
+const SALES_CHANNELS_FIELD = ["salesChannels"];
+const WEB_DATA_FIELD = ["webAddress", "webExempt"];
+const INDUSTRY_CODE_FIELD = ["industryCodes"];
+const SCTA_FIELD = ["sctaUrl", "sctaExempt"];
+const businessLinesConfigurations = {
+  industryCodes: { rule: "REQUIRED" },
+  salesChannels: { rule: "REQUIRED" },
+  webAddress: { rule: "webAddressRequired" },
+  webExempt: { rule: "OPTIONAL" },
+  sctaUrl: { rule: "sctaUrlRequired" },
+  sctaExempt: { rule: "OPTIONAL" }
+};
+const businessLinesForms = {
+  industryCodesForm: {
+    formId: "industryCodesForm",
+    formName: "industryCodesForm",
+    fields: INDUSTRY_CODE_FIELD
+  },
+  salesChannelsForm: {
+    formId: "salesChannelsForm",
+    formName: "paymentProcessing",
+    fields: [...SALES_CHANNELS_FIELD, ...WEB_DATA_FIELD]
+  },
+  sctaForm: {
+    formId: "sctaForm",
+    formName: "japaneseCommercialDisclosure",
+    fields: SCTA_FIELD
+  }
+};
+const businessLineTypes = ["acquiring"];
+const divider = "adyen-kyc-divider";
+const styles = {
+  divider
+};
+const Divider = () => /* @__PURE__ */ jsx("hr", { className: styles.divider });
+const createBusinessLine = async (legalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/businessLines`
+    },
+    data
+  );
+};
+const useCreateBusinessLine = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useMutation({
+    mutationFn: (data) => createBusinessLine(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+const updateBusinessLine = async (legalEntityId, baseUrl, data) => {
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/businessLines/${data.id}`
+    },
+    data
+  );
+};
+const useUpdateBusinessLine = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useMutation({
+    mutationFn: (data) => updateBusinessLine(rootLegalEntityId.value, baseUrl.value, data),
+    ...options
+  });
+};
+export {
+  Divider as D,
+  INDUSTRY_CODE_FIELD as I,
+  SALES_CHANNELS_FIELD as S,
+  WEB_DATA_FIELD as W,
+  IndustryCodeField as a,
+  useCreateBusinessLine as b,
+  useUpdateBusinessLine as c,
+  businessLineTypes as d,
+  shouldSignNewPci as e,
+  SCTA_FIELD as f,
+  selectedBusinessLine as g,
+  businessLinesConfigurations as h,
+  industryCodeFieldMetadata as i,
+  businessLinesForms as j,
+  salesChannelsWithWebData as s,
+  useIndustryCodes as u
+};

package/dist/{useUpdateLegalEntity-CIZP-vhE.js → useUpdateLegalEntity-tRw1V_Mt.js}

@@ -2,13 +2,14 @@
 {
   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] = "a328f15d-01a7-4cc2-9b0d-e3ad34766cd3", e._sentryDebugIdIdentifier = "sentry-dbid-a328f15d-01a7-4cc2-9b0d-e3ad34766cd3");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "762a78bb-4916-4a5c-905d-643ca4cd5034", e._sentryDebugIdIdentifier = "sentry-dbid-762a78bb-4916-4a5c-905d-643ca4cd5034");
   } catch (e) {
   }
 }
 ;
-import { b as useApiContext, a2 as useQueryClient, a0 as useMutation, k as httpPost } from "./StoreProvider-DTMSAVgy.js";
-import { c as useInvalidateRootLegalEntity } from "./useToastContext-BQYYaLd-.js";
+import { useQueryClient, useMutation } from "@tanstack/preact-query";
+import { a as useInvalidateRootLegalEntity } from "./useToastContext-D643iewp.js";
+import { b as useApiContext, $ as httpPost } from "./StoreProvider-99-ewU62.js";
 const updateLegalEntity = async (rootLegalEntityId, baseUrl, data) => {
   return httpPost(
     {