@adyen/kyc-components 3.94.0 → 3.95.0-beta.0

package/dist/useNavigate-DE0sTmpX.js

@@ -0,0 +1,265 @@
+;
+{
+  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] = "324c8dab-549d-4b52-bd05-eaa614b7bb7f", e._sentryDebugIdIdentifier = "sentry-dbid-324c8dab-549d-4b52-bd05-eaa614b7bb7f");
+  } catch (e) {
+  }
+}
+;
+import { matchRoute, useLocation } from "wouter-preact";
+import { lazy } from "preact/compat";
+import { j as TaskTypes } from "./StoreProvider-BL3nK1iO.js";
+const Introduction = lazy(
+  async () => (await import("./Introduction-D1Ki78MP.js")).Introduction
+);
+const BusinessTypeSelectionPage = lazy(
+  async () => (await import("./BusinessTypeSelectionPage-BamCO_8X.js")).BusinessTypeSelectionPage
+);
+const SingpassSelection = lazy(
+  async () => (await import("./SingpassSelection-DE4uUTZo.js")).SingpassSelection
+);
+const AccountSetupRejected = lazy(
+  async () => (await import("./AccountSetupRejected-BgPC6a82.js")).AccountSetupRejected
+);
+const DecisionMakers = lazy(
+  async () => (await import("./DecisionMakers-Dj2lHuCW.js")).DecisionMakers
+);
+const CustomerSupport = lazy(
+  async () => (await import("./CustomerSupport-CZAM9Fzm.js")).CustomerSupport
+);
+const Review = lazy(async () => (await import("./Review-Cj1WCiGQ.js")).Review);
+const SignPCIComponent = lazy(
+  async () => (await import("./SignPCIComponent-OxWCtP3x.js")).SignPCIComponent
+);
+const AcceptTermsOfService = lazy(
+  async () => (await import("./AcceptTermsOfServiceComponent-DQBTbYHm.js")).AcceptTermsOfServiceComponent
+);
+const TaxReportingDropin = lazy(
+  async () => (await import("./TaxReportingDropin-xYD4YqWR.js")).TaxReportingDropin
+);
+const PayoutDetailsPage = lazy(
+  async () => (await import("./PayoutDetailsDropin-Cqeomvbg.js").then((n) => n.a)).PayoutDetailsPage
+);
+const RootBusinessDetailsPage = lazy(
+  async () => (await import("./RootBusinessDetailsPage-9NXM1XdC.js")).RootBusinessDetailsPage
+);
+const RootBusinessLinesPage = lazy(
+  async () => (await import("./RootBusinessLinesPage-YxGXibwW.js")).RootBusinessLinesPage
+);
+const SoleProprietorshipPage = lazy(
+  async () => (await import("./SoleProprietorshipPage-BzpFPKOl.js")).SoleProprietorshipPage
+);
+const TrustMemberCompanyPage = lazy(
+  async () => (await import("./TrustMemberCompanyPage-WwsnSV7c.js")).TrustMemberCompanyPage
+);
+const TrustMemberIndividualPage = lazy(
+  async () => (await import("./TrustMemberIndividualPage-27y1WJMM.js")).TrustMemberIndividualPage
+);
+const TrustMemberRoleAndTypePage = lazy(
+  async () => (await import("./TrustMemberRoleAndTypePage-DHCLuLa-.js")).TrustMemberRoleAndTypePage
+);
+const TrustMembersOverview = lazy(
+  async () => (await import("./TrustMembersOverview-CqdtBx67.js")).TrustMembersOverview
+);
+const UnincorporatedPartnershipMemberCompanyPage = lazy(
+  async () => (await import("./UnincorporatedPartnershipMemberCompanyPage-CBw2IY6X.js")).UnincorporatedPartnershipMemberCompanyPage
+);
+const UnincorporatedPartnershipIndividualPage = lazy(
+  async () => (await import("./UnincorporatedPartnershipIndividualPage-xOJ-Kusf.js")).UnincorporatedPartnershipIndividualPage
+);
+const UnincorporatedPartnershipMemberRoleAndTypePage = lazy(
+  async () => (await import("./UnincorporatedPartnershipMemberRoleAndTypePage-B4fDDHnW.js")).UnincorporatedPartnershipMemberRoleAndTypePage
+);
+const UnincorporatedPartnershipMembersOverview = lazy(
+  async () => (await import("./UnincorporatedPartnershipMembersOverview-BrBvKluu.js")).UnincorporatedPartnershipMembersOverview
+);
+const BusinessFinancingPage = lazy(
+  async () => (await import("./BusinessFinancingPage-CARcv8Qh.js")).BusinessFinancingPage
+);
+const TrustDetailsPage = lazy(
+  async () => (await import("./TrustDetailsPage-JQ-U6HZk.js")).TrustDetailsPage
+);
+const SourceOfFundsPage = lazy(
+  async () => (await import("./SourceOfFundsPage-CESAo3kl.js")).SourceOfFundsPage
+);
+const RootIndividualDetailsPage = lazy(
+  async () => (await import("./RootIndividualDetailsPage-DX1rjTXN.js")).RootIndividualDetailsPage
+);
+const LegalRepresentativeDetailsPage = lazy(
+  async () => (await import("./LegalRepresentativeDetailsPage-B0UoHJQJ.js")).LegalRepresentativeDetailsPage
+);
+const DecisionMakerDetailsPage = lazy(
+  async () => (await import("./DecisionMakerDetailsPage-CgEYI6wt.js")).DecisionMakerDetailsPage
+);
+const ROUTE_CONFIG = {
+  [TaskTypes.TASKS_OVERVIEW]: { path: "/tasks" },
+  [TaskTypes.INTRODUCTION]: { path: "/introduction", Component: Introduction },
+  [TaskTypes.BUSINESS_TYPE_SELECTION]: {
+    path: "/business-type-selection",
+    Component: BusinessTypeSelectionPage
+  },
+  [TaskTypes.SINGPASS_SELECTION]: { path: "/singpass-selection", Component: SingpassSelection },
+  [TaskTypes.INDIVIDUAL]: { path: "/individual", Component: RootIndividualDetailsPage },
+  [TaskTypes.BUSINESS_DETAILS]: { path: "/business", Component: RootBusinessDetailsPage },
+  [TaskTypes.ACQUIRING_BUSINESS_LINE]: {
+    path: "/business-lines",
+    Component: RootBusinessLinesPage
+  },
+  [TaskTypes.DECISION_MAKER_OVERVIEW]: { path: "/decision-makers", Component: DecisionMakers },
+  [TaskTypes.DECISION_MAKER]: {
+    path: "/decision-maker/:parentId/:decisionMakerId?",
+    Component: DecisionMakerDetailsPage
+  },
+  [TaskTypes.PAYOUT]: { path: "/payout/:transferInstrumentId?", Component: PayoutDetailsPage },
+  [TaskTypes.PAYIN]: { path: "/payin/:transferInstrumentId?", Component: PayoutDetailsPage },
+  [TaskTypes.SERVICE_AGREEMENT]: { path: "/service-agreement", Component: AcceptTermsOfService },
+  [TaskTypes.PCI_DSS]: { path: "/pci-dss", Component: SignPCIComponent },
+  [TaskTypes.REVIEW]: { path: "/review", Component: Review },
+  [TaskTypes.CUSTOMER_SUPPORT]: { path: "/customer-support", Component: CustomerSupport },
+  [TaskTypes.CAPABILITY_REJECTED]: {
+    path: "/capability-rejected",
+    Component: AccountSetupRejected
+  },
+  [TaskTypes.LEGAL_REPRESENTATIVE_DETAILS]: {
+    path: "/legal-representative",
+    Component: LegalRepresentativeDetailsPage
+  },
+  [TaskTypes.SOURCE_OF_FUNDS]: { path: "/source-of-funds", Component: SourceOfFundsPage },
+  [TaskTypes.BUSINESS_FINANCING]: { path: "/business-financing", Component: BusinessFinancingPage },
+  [TaskTypes.TAX_REPORTING]: { path: "/tax-reporting", Component: TaxReportingDropin },
+  [TaskTypes.SOLE_PROPRIETOR_COMPANY]: {
+    path: "/sole-proprietor",
+    Component: SoleProprietorshipPage
+  },
+  [TaskTypes.TRUST]: { path: "/trust", Component: TrustDetailsPage },
+  [TaskTypes.TRUST_MEMBER]: { path: "/trust/member" },
+  [TaskTypes.TRUST_MEMBER_OVERVIEW]: { path: "/trust/members", Component: TrustMembersOverview },
+  [TaskTypes.TRUST_MEMBER_ROLE_AND_TYPE]: {
+    path: "/trust/member/role-and-type/:memberId?",
+    Component: TrustMemberRoleAndTypePage
+  },
+  [TaskTypes.TRUST_MEMBER_INDIVIDUAL]: {
+    path: "/trust/member/:memberId/individual",
+    Component: TrustMemberIndividualPage
+  },
+  [TaskTypes.TRUST_MEMBER_COMPANY]: {
+    path: "/trust/member/:memberId/company",
+    Component: TrustMemberCompanyPage
+  },
+  [TaskTypes.TRUST_MEMBER_COMPANY_OWNER]: {
+    path: "/trust/member/:memberId/company-owner/:parentId/:decisionMakerId?",
+    Component: DecisionMakerDetailsPage
+  },
+  [TaskTypes.UNINCORPORATED_PARTNERSHIP]: {
+    path: "/partnership",
+    Component: TrustDetailsPage
+  },
+  [TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_OVERVIEW]: {
+    path: "/partnership/members",
+    Component: UnincorporatedPartnershipMembersOverview
+  },
+  [TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_ROLE_AND_TYPE]: {
+    path: "/partnership/member/role-and-type/:memberId?",
+    Component: UnincorporatedPartnershipMemberRoleAndTypePage
+  },
+  [TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_INDIVIDUAL]: {
+    path: "/partnership/member/:memberId/individual",
+    Component: UnincorporatedPartnershipIndividualPage
+  },
+  [TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY]: {
+    path: "/partnership/member/:memberId/company",
+    Component: UnincorporatedPartnershipMemberCompanyPage
+  },
+  [TaskTypes.UNINCORPORATED_PARTNERSHIP_MEMBER_COMPANY_OWNER]: {
+    path: "/partnership/member/:memberId/company-owner/:parentId/:decisionMakerId?",
+    Component: DecisionMakerDetailsPage
+  }
+};
+const ROUTE_PATHS = Object.fromEntries(
+  Object.entries(ROUTE_CONFIG).map(([key, entry]) => [key, entry.path])
+);
+const buildPath = (task, params) => {
+  const routePath = ROUTE_PATHS[task];
+  const segments = routePath.split("/").filter(Boolean);
+  const built = segments.map((seg) => {
+    const isOptional = seg.endsWith("?");
+    const isParam = seg.startsWith(":");
+    if (!isParam) return seg;
+    const paramName = seg.slice(1, isOptional ? -1 : void 0);
+    const value = params?.[paramName];
+    if (!value && isOptional) return null;
+    if (!value) throw new Error(`Missing required param "${paramName}" for route "${task}"`);
+    return value;
+  }).filter((s) => s !== null);
+  return "/" + built.join("/");
+};
+const detectBasePath = (parser, pathname = window.location.pathname) => {
+  const pathSegments = pathname.split("/").filter(Boolean);
+  const sortedRoutes = Object.values(ROUTE_PATHS).sort(
+    (a, b) => b.split("/").filter(Boolean).length - a.split("/").filter(Boolean).length
+  );
+  for (let i = 0; i < pathSegments.length; i++) {
+    const candidatePath = "/" + pathSegments.slice(i).join("/");
+    for (const routePath of sortedRoutes) {
+      const [match] = matchRoute(parser, routePath, candidatePath);
+      if (match) {
+        const baseSegments = pathSegments.slice(0, i);
+        return baseSegments.length > 0 ? "/" + baseSegments.join("/") : "/";
+      }
+    }
+  }
+  const trimmed = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+  return trimmed || "/";
+};
+const useNavigate = () => {
+  const [, setLocation] = useLocation();
+  const withSearch = (path) => path + window.location.search;
+  const to = (task, params) => {
+    if (task === "default") {
+      setLocation(withSearch("/"));
+      return;
+    }
+    setLocation(withSearch(buildPath(task, params)));
+  };
+  const back = (stepCount = 1) => {
+    window.history.go(-stepCount);
+  };
+  const replace = (task, params) => {
+    setLocation(withSearch(buildPath(task, params)), { replace: true });
+  };
+  return { to, back, replace };
+};
+export {
+  AccountSetupRejected as A,
+  BusinessTypeSelectionPage as B,
+  CustomerSupport as C,
+  DecisionMakers as D,
+  Introduction as I,
+  LegalRepresentativeDetailsPage as L,
+  PayoutDetailsPage as P,
+  ROUTE_PATHS as R,
+  SingpassSelection as S,
+  TrustMembersOverview as T,
+  UnincorporatedPartnershipMembersOverview as U,
+  RootIndividualDetailsPage as a,
+  RootBusinessDetailsPage as b,
+  Review as c,
+  DecisionMakerDetailsPage as d,
+  TrustMemberRoleAndTypePage as e,
+  TrustMemberIndividualPage as f,
+  TrustMemberCompanyPage as g,
+  TrustDetailsPage as h,
+  UnincorporatedPartnershipMemberRoleAndTypePage as i,
+  UnincorporatedPartnershipIndividualPage as j,
+  UnincorporatedPartnershipMemberCompanyPage as k,
+  SignPCIComponent as l,
+  SoleProprietorshipPage as m,
+  AcceptTermsOfService as n,
+  SourceOfFundsPage as o,
+  BusinessFinancingPage as p,
+  TaxReportingDropin as q,
+  RootBusinessLinesPage as r,
+  detectBasePath as s,
+  useNavigate as u
+};

package/dist/{useOnboardingStatus-CJrlnkvv.js → useOnboardingStatus-DhK2qF95.js}

@@ -8,7 +8,7 @@
 }
 ;
 import { useQuery } from "@tanstack/preact-query";
-import { b as useApiContext, k as httpGet } from "./StoreProvider-CsZ-qrGt.js";
+import { b as useApiContext, k as httpGet } from "./StoreProvider-BL3nK1iO.js";
 const getOnboardingStatus = async (legalEntityId, baseUrl) => {
   return httpGet({
     baseUrl,

package/dist/usePciQuestionnaireList-DsgAv5Ql.js

@@ -0,0 +1,29 @@
+;
+{
+  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] = "eb3e49da-9999-40d6-9020-545a4e3401ce", e._sentryDebugIdIdentifier = "sentry-dbid-eb3e49da-9999-40d6-9020-545a4e3401ce");
+  } catch (e) {
+  }
+}
+;
+import { useQuery } from "@tanstack/preact-query";
+import { b as useApiContext, k as httpGet } from "./StoreProvider-BL3nK1iO.js";
+const getPciQuestionnaireList = async (legalEntityId, baseUrl) => {
+  return httpGet({
+    baseUrl,
+    path: `legalEntities/${legalEntityId}/pci/questionnaires`
+  });
+};
+const usePciQuestionnaireList = (options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["pciQuestionnaireList"],
+    queryFn: () => getPciQuestionnaireList(rootLegalEntityId.value, baseUrl.value),
+    ...options
+  });
+};
+export {
+  getPciQuestionnaireList as g,
+  usePciQuestionnaireList as u
+};

package/dist/useSalesChannels-DUTiDcGq.js

@@ -0,0 +1,65 @@
+;
+{
+  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] = "ea0b0020-c2a2-4f82-b873-0d44c11f6d82", e._sentryDebugIdIdentifier = "sentry-dbid-ea0b0020-c2a2-4f82-b873-0d44c11f6d82");
+  } catch (e) {
+  }
+}
+;
+import { useQuery } from "@tanstack/preact-query";
+import { b as useApiContext, $ as httpPost, B as useSettingsContext } from "./StoreProvider-BL3nK1iO.js";
+import { useMemo } from "preact/hooks";
+import { u as useBusinessLines } from "./useBusinessLines-BD1Yg8Ja.js";
+import { S as SettingNames } from "./TaskVerificationStatus-ycoS73dK.js";
+const getPciStatus = async (legalEntityId, baseUrl, data) => {
+  const filteredData = {
+    ...data,
+    additionalSalesChannels: data.additionalSalesChannels?.filter(
+      (channel) => channel !== "payByLink"
+    )
+  };
+  return httpPost(
+    {
+      baseUrl,
+      path: `legalEntities/${legalEntityId}/pci/signingRequired`
+    },
+    filteredData
+  );
+};
+const usePciStatus = (data, options) => {
+  const { rootLegalEntityId, baseUrl } = useApiContext();
+  return useQuery({
+    queryKey: ["pciStatus", data],
+    queryFn: () => getPciStatus(rootLegalEntityId.value, baseUrl.value, data),
+    staleTime: 0,
+    ...options
+  });
+};
+function useSalesChannels() {
+  const { isSettingEnabled } = useSettingsContext();
+  const { data: existingBusinessLines } = useBusinessLines(["paymentProcessing"]);
+  return useMemo(() => {
+    const settings = [];
+    const businessLinesSalesChannels = [
+      ...new Set(existingBusinessLines?.flatMap((item) => item.salesChannels ?? []))
+    ];
+    if (isSettingEnabled(SettingNames.RequirePciSignEcommerce)) {
+      settings.push("eCommerce");
+    }
+    if (isSettingEnabled(SettingNames.RequirePciSignPos)) {
+      settings.push("pos");
+    }
+    if (isSettingEnabled(SettingNames.RequirePciSignEcomMoto)) {
+      settings.push("ecomMoto");
+    }
+    if (isSettingEnabled(SettingNames.RequirePciSignPosMoto)) {
+      settings.push("posMoto");
+    }
+    return isSettingEnabled("allowBusinessLines") ? businessLinesSalesChannels : settings;
+  }, [existingBusinessLines, isSettingEnabled]);
+}
+export {
+  usePciStatus as a,
+  useSalesChannels as u
+};

package/dist/{useScenarios-CkgrmOF-.js → useScenarios-BxbmDi2R.js}

@@ -2,13 +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] = "3fba2170-7c0d-4b84-9355-f87181f04ff3", e._sentryDebugIdIdentifier = "sentry-dbid-3fba2170-7c0d-4b84-9355-f87181f04ff3");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "688d85b7-1082-4364-a70a-cb566cc8e437", e._sentryDebugIdIdentifier = "sentry-dbid-688d85b7-1082-4364-a70a-cb566cc8e437");
   } catch (e) {
   }
 }
 ;
 import { useQuery, skipToken } from "@tanstack/preact-query";
-import { b as useApiContext, ak as entriesOf, ag as Scenarios, k as httpGet } from "./StoreProvider-CsZ-qrGt.js";
+import { b as useApiContext, ad as entriesOf, ay as Scenarios, k as httpGet } from "./StoreProvider-BL3nK1iO.js";
 const getScenarios = async (legalEntityId, baseUrl, legalEntityType, countryCode) => {
   const scenarioParams = new URLSearchParams({
     countryCode,

package/dist/useSetting-DwC0bC4k.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] = "88e83ebf-8d7e-40ed-ad66-d90e2848a57c", e._sentryDebugIdIdentifier = "sentry-dbid-88e83ebf-8d7e-40ed-ad66-d90e2848a57c");
+  } catch (e) {
+  }
+}
+;
+import { useContext } from "preact/hooks";
+import { bi as SettingsContext } from "./StoreProvider-BL3nK1iO.js";
+const useSetting = (settingName) => {
+  const context = useContext(SettingsContext);
+  const { getSetting } = context;
+  return getSetting(settingName);
+};
+export {
+  useSetting as u
+};

package/dist/useTaskStatus-Cps0L-Yp.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] = "0ed34ccb-7d96-44b8-9b77-34fbd41baa9e", e._sentryDebugIdIdentifier = "sentry-dbid-0ed34ccb-7d96-44b8-9b77-34fbd41baa9e");
+  } catch (e) {
+  }
+}
+;
+import { useQuery } from "@tanstack/preact-query";
+import { q as TaskStatuses, a3 as createLogger, b as useApiContext, k as httpGet } from "./StoreProvider-BL3nK1iO.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-DFLF3xas.js → useTermsOfServiceStatus-COugffxI.js}

@@ -8,7 +8,7 @@
 }
 ;
 import { useQuery } from "@tanstack/preact-query";
-import { b as useApiContext, k as httpGet } from "./StoreProvider-CsZ-qrGt.js";
+import { b as useApiContext, k as httpGet } from "./StoreProvider-BL3nK1iO.js";
 const getTermsOfServiceAcceptanceInfos = async (legalEntityId, baseUrl) => {
   return httpGet({
     baseUrl,

package/dist/{useToastContext-uSKjdph9.js → useToastContext-DBDF60Ps.js}

@@ -2,14 +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] = "6170884f-5a2f-452c-8da2-49d3de4ea4a8", e._sentryDebugIdIdentifier = "sentry-dbid-6170884f-5a2f-452c-8da2-49d3de4ea4a8");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "e6f9ba7a-1bf8-4e1f-97d8-0224dd9cc0f6", e._sentryDebugIdIdentifier = "sentry-dbid-e6f9ba7a-1bf8-4e1f-97d8-0224dd9cc0f6");
   } catch (e) {
   }
 }
 ;
 import { useQueryClient } from "@tanstack/preact-query";
 import { useCallback, useContext } from "preact/hooks";
-import { o as createLogger, b as useApiContext, am as ToastContext } from "./StoreProvider-CsZ-qrGt.js";
+import { a3 as createLogger, b as useApiContext, af as ToastContext } from "./StoreProvider-BL3nK1iO.js";
 const logger = createLogger();
 const QUERIES_TO_INVALIDATE_WHEN_ROOT_LE_IS_INVALIDATED = [
   "businessLines",

package/dist/useTrustMembers-ymPJMufc.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] = "aa050a7c-c33f-4f62-aaed-4cf7759360e0", e._sentryDebugIdIdentifier = "sentry-dbid-aa050a7c-c33f-4f62-aaed-4cf7759360e0");
+  } catch (e) {
+  }
+}
+;
+import { useMemo } from "preact/hooks";
+import { aa as getOwnEntityAssociations, bn as TrustMemberTypes, c as useLegalEntity, o as LegalEntityTypes, R as ROOT_LE, v as useExperimentsContext } from "./StoreProvider-BL3nK1iO.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-DlZrp3qi.js";
+import { skipToken } from "@tanstack/preact-query";
+import { g as getLegalEntityNameBasedOnType } from "./getName-C1AIqAns.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-BmLKVfkf.js → useUnincorporatedPartnershipMembers-ZlPU6E-_.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] = "6d780634-f815-4567-b95a-26bdd2e6e1b4", e._sentryDebugIdIdentifier = "sentry-dbid-6d780634-f815-4567-b95a-26bdd2e6e1b4");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "07b9650b-7e50-4778-8f2d-ad4adfacb9f2", e._sentryDebugIdIdentifier = "sentry-dbid-07b9650b-7e50-4778-8f2d-ad4adfacb9f2");
   } catch (e) {
   }
 }
 ;
 import { useMemo } from "preact/hooks";
-import { t as LegalEntityTypes, a8 as getOwnEntityAssociations, c as useLegalEntity, R as ROOT_LE } from "./StoreProvider-CsZ-qrGt.js";
-import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-V0OP9ejx.js";
+import { o as LegalEntityTypes, aa as getOwnEntityAssociations, c as useLegalEntity, R as ROOT_LE } from "./StoreProvider-BL3nK1iO.js";
+import { u as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-DlZrp3qi.js";
 import { U as UnincorporatedPartnershipMemberTypes } from "./unincorporated-partnership-MeN1dp53.js";
-import { g as getLegalEntityNameBasedOnType } from "./getName-BxKx8lLd.js";
+import { g as getLegalEntityNameBasedOnType } from "./getName-C1AIqAns.js";
 const getMemberOwnerId = (memberId, entityAssociations) => entityAssociations.find((association) => association.associatorId === memberId)?.legalEntityId;
 const convertEntityAssociationIntoUnincorporatedPartnershipMember = (association) => {
   if (association.entityType === LegalEntityTypes.INDIVIDUAL || association.entityType === LegalEntityTypes.ORGANIZATION)