@mx-cartographer/experiences 6.26.18-alpha.mega1 → 6.26.18-alpha.mega3

package/dist/accounts/components/detailsdrawer/Transactions/TransactionsTab/index.es.js

@@ -0,0 +1,37 @@
+import { jsxs as f, Fragment as d, jsx as r } from "react/jsx-runtime";
+import t from "react";
+import { observer as T } from "mobx-react-lite";
+import { subDays as l, startOfToday as p, endOfToday as C } from "date-fns";
+import S from "../../../../../transactions/components/shared/TransactionList/index.es.js";
+import A from "../../../../../transactions/components/shared/TransactionDetails/index.es.js";
+import { useAccountUiStore as E } from "../../../../hooks/useUiStore/index.es.js";
+import { useEvent as _, useGlobalCopyStore as b, useTransactionStore as g } from "../../../../../common/context/hooks/index.es.js";
+import { ANALYTICS_EVENTS as y } from "../../../../../common/constants/Analytics/index.es.js";
+import N from "../../../../../common/components/drawer/Drawer/index.es.js";
+const O = () => {
+  const [o, s] = t.useState(""), { onEvent: i } = _(), { selectedAccount: e } = E(), { accounts: n } = b(), { setFilter: m, sortedTransactions: a } = g(), c = t.useMemo(
+    () => a.find((u) => u.guid === o),
+    [o, a]
+  );
+  return t.useEffect(() => {
+    m({
+      dateRange: { start: l(p(), 90), end: C() },
+      accounts: [e.guid]
+    });
+  }, [e]), t.useEffect(() => i(y.ACCOUNT_DETAILS_VIEW_TRANSACTIONS), []), /* @__PURE__ */ f(d, { children: [
+    /* @__PURE__ */ r(S, { onClick: s }),
+    c && /* @__PURE__ */ r(
+      N,
+      {
+        ariaLabelClose: n.close_drawer,
+        isOpen: !!o,
+        onClose: () => s(""),
+        title: n.transaction_drawer_title,
+        children: /* @__PURE__ */ r(A, { transaction: c })
+      }
+    )
+  ] });
+}, G = T(O);
+export {
+  G as default
+};

package/dist/accounts/constants/Accounts/index.es.js

@@ -0,0 +1,5 @@
+var t = /* @__PURE__ */ ((r) => (r.Loading = "loading", r.Error = "error", r))(t || {}), a = /* @__PURE__ */ ((r) => (r.Currency = "currency", r.Date = "date", r.Input = "input", r.Select = "select", r))(a || {});
+export {
+  a as FieldType,
+  t as MemberConnectionStatus
+};

package/dist/accounts/hooks/useGetMergeableAccounts/index.es.js

@@ -0,0 +1,11 @@
+import { useAccountUiStore as r } from "../useUiStore/index.es.js";
+import { useAccountStore as u } from "../../../common/context/hooks/index.es.js";
+const i = () => {
+  const { accounts: c } = u(), { selectedAccount: o, selectedMember: e } = r();
+  return c.filter(
+    (t) => t.member_guid === e.guid && e.successfully_aggregated_at && t.guid !== o.guid
+  );
+};
+export {
+  i as useGetMergeableAccounts
+};

package/dist/accounts/hooks/useUiStore/index.es.js

@@ -0,0 +1,11 @@
+import t from "react";
+import { GlobalDataContext as o } from "../../../common/context/GlobalDataProvider/index.es.js";
+import { useAccountStore as e } from "../../../common/context/hooks/index.es.js";
+const i = () => {
+  if (!t.useContext(o))
+    throw new Error("useCategoryUiStore() must be used within the GlobalDataContext");
+  return e().uiStore;
+};
+export {
+  i as useAccountUiStore
+};

package/dist/accounts/index.es.js

@@ -0,0 +1,26 @@
+import { default as o } from "./AccountsWidget/index.es.js";
+import { default as c } from "./AccountsMiniWidget/index.es.js";
+import { default as a } from "./ConnectMiniWidget/index.es.js";
+import { default as f } from "./components/detailsdrawer/Accounts/AccountDetailsHeader/index.es.js";
+import { default as s } from "./components/detailsdrawer/Accounts/AccountDetailsContent/index.es.js";
+import { getAccountBalanceDetails as p, getAccountDetailFields as m } from "./utils/AccountFields/index.es.js";
+import { FieldType as x, MemberConnectionStatus as A } from "./constants/Accounts/index.es.js";
+import { useGetMergeableAccounts as D } from "./hooks/useGetMergeableAccounts/index.es.js";
+import { AccountApi as C } from "./api/AccountApi/index.es.js";
+import { AccountStore as W } from "./stores/AccountStore/index.es.js";
+import { useAccountUiStore as F } from "./hooks/useUiStore/index.es.js";
+export {
+  C as AccountApi,
+  s as AccountDetailsContent,
+  f as AccountDetailsHeader,
+  W as AccountStore,
+  c as AccountsMiniWidget,
+  o as AccountsWidget,
+  a as ConnectMiniWidget,
+  x as FieldType,
+  A as MemberConnectionStatus,
+  p as getAccountBalanceDetails,
+  m as getAccountDetailFields,
+  F as useAccountUiStore,
+  D as useGetMergeableAccounts
+};

package/dist/accounts/stores/AccountStore/index.es.js

@@ -0,0 +1,204 @@
+import { makeAutoObservable as d, runInAction as i } from "mobx";
+import { AccountApi as h } from "../../api/AccountApi/index.es.js";
+import { UiStore as l } from "../UiStore/index.es.js";
+import { AccountType as n, ConnectionStatus as a, ErrorStatuses as _, ProcessingStatuses as m, MfaStatuses as A } from "../../../common/types/Account/index.es.js";
+class I {
+  globalStore;
+  api = new h("/", "");
+  accounts = [];
+  institutions = [];
+  members = [];
+  uiStore;
+  constructor(t) {
+    this.globalStore = t, this.uiStore = new l(), this.api = new h(t.endpoint, t.sessionToken), d(this);
+  }
+  loadAccountData = async ({
+    accounts: t,
+    institutions: e
+  } = {}) => {
+    await Promise.all([this.loadAccounts(t), this.loadInstitutions(e)]);
+  };
+  get cashAccounts() {
+    return this.accounts.filter(
+      (t) => t.account_type === n.CASH || t.account_type === n.CHECKING || t.account_type === n.PREPAID || t.account_type === n.SAVINGS || t.account_type === n.CHECKING_LINE_OF_CREDIT
+    );
+  }
+  get cashBalance() {
+    return this.cashAccounts.reduce((t, e) => t + (e?.balance || 0), 0);
+  }
+  get checkingAccounts() {
+    return this.accounts.filter((t) => t.account_type === n.CHECKING);
+  }
+  get debtAccounts() {
+    return this.accounts.filter(
+      (t) => t.account_type === n.CREDIT_CARD || t.account_type === n.LOAN || t.account_type === n.MORTGAGE || t.account_type === n.LINE_OF_CREDIT || t.account_type === n.CHECKING_LINE_OF_CREDIT
+    );
+  }
+  get finstrongAccounts() {
+    const t = /* @__PURE__ */ new Set([
+      n.CHECKING,
+      n.SAVINGS,
+      n.CREDIT_CARD,
+      n.INVESTMENT
+    ]);
+    return this.accounts.filter((e) => t.has(e.account_type));
+  }
+  get investmentAccounts() {
+    return this.accounts.filter(
+      (t) => t.account_type === n.INVESTMENT
+    );
+  }
+  get savingsAccounts() {
+    return this.accounts.filter((t) => t.account_type === n.SAVINGS);
+  }
+  get visibleAccounts() {
+    return this.accounts.filter((t) => !t.is_hidden);
+  }
+  get visibleCashAccounts() {
+    return this.cashAccounts.filter((t) => !t.is_hidden);
+  }
+  get visibleCashBalance() {
+    return this.visibleCashAccounts.reduce((t, e) => t + (e?.balance || 0), 0);
+  }
+  get visibleCheckingAccounts() {
+    return this.checkingAccounts.filter((t) => !t.is_hidden);
+  }
+  get visibleDebtAccounts() {
+    return this.debtAccounts.filter((t) => !t.is_hidden);
+  }
+  get visibleFinstrongAccounts() {
+    return this.finstrongAccounts.filter(
+      (t) => !(t.is_closed || t.is_deleted || t.is_hidden)
+    );
+  }
+  get visibleInvestmentAccounts() {
+    return this.investmentAccounts.filter((t) => !t.is_hidden);
+  }
+  get visibleSavingsAccounts() {
+    return this.savingsAccounts.filter((t) => !t.is_hidden);
+  }
+  addAccount = async (t) => {
+    try {
+      const e = await this.api.createAccount(t);
+      i(() => {
+        this.accounts = [...this.accounts, e];
+      });
+    } catch (e) {
+      console.error(`Error occurred while adding an account: ${e}`);
+    }
+  };
+  augmentAccounts = (t = this.accounts) => {
+    const e = [];
+    return t.forEach((c) => {
+      const s = this.members.findIndex(
+        (r) => r.guid === c.member_guid
+      );
+      if (s > -1) {
+        let r = a.Connected;
+        const o = this.members[s];
+        _.includes(o.connection_status) ? r = a.Error : m.includes(o.connection_status) ? r = a.Processing : A.includes(o.connection_status) && (r = a.RequiresMfa);
+        let u = c.user_name || c.feed_name || "";
+        c.account_number && (u = `${u} *${c.account_number}`), e.push({
+          ...c,
+          institutionName: u,
+          memberName: o.name,
+          connectionStatus: r
+        }), this.members[s].connectionStatus = r;
+      }
+    }), e;
+  };
+  loadAccounts = async (t) => {
+    await this.loadMembers();
+    try {
+      const e = t || await this.api.getAccounts();
+      i(() => {
+        this.accounts = this.sortAccounts(this.augmentAccounts(e));
+      });
+    } catch (e) {
+      console.error(`Error occurred while loading accounts: ${e}`);
+    }
+  };
+  loadInstitutions = async (t) => {
+    try {
+      const e = t || await this.api.getInstitutions();
+      i(() => {
+        this.institutions = e;
+      });
+    } catch (e) {
+      console.error(`Error occurred while loading institutions: ${e}`);
+    }
+  };
+  loadMembers = async () => {
+    try {
+      const t = await this.api.getMembers();
+      i(() => {
+        this.members = t;
+      });
+    } catch (t) {
+      console.error(`Error occurred while loading members: ${t}`);
+    }
+  };
+  mergeAccounts = async (t) => {
+    try {
+      const e = await this.api.mergeAccounts(t), c = e[Object.keys(e)[0]];
+      i(() => {
+        const s = this.accounts.findIndex((o) => o.guid === t[1]);
+        this.accounts.splice(s, 1);
+        const r = this.accounts.findIndex((o) => o.guid === t[0]);
+        this.accounts.splice(r, 1, c);
+      });
+    } catch (e) {
+      console.error(`Error occurred while merging accounts: ${e}`);
+    }
+  };
+  sortAccounts = (t = this.accounts) => t.sort((e, c) => e.account_type > c.account_type ? 1 : e.account_type < c.account_type ? -1 : (e.name || "") > (c.name || "") ? 1 : (e.name || "") < (c.name || "") ? -1 : 0);
+  refreshAccounts = async () => {
+    this.uiStore.setIsLoading(!0), await Promise.all([this.loadAccounts(), this.loadInstitutions()]), this.uiStore.setIsLoading(!1);
+  };
+  refreshMembers = async () => {
+    try {
+      await this.api.refreshAllMembers(), await this.loadMembers();
+    } catch (t) {
+      console.error(`Error occurredwhile refreshing members: ${t}`);
+    }
+  };
+  removeAccount = async (t) => {
+    try {
+      await this.api.deleteAccount(t), i(() => {
+        const e = this.accounts.findIndex((c) => c.guid === t);
+        this.accounts.splice(e, 1);
+      });
+    } catch (e) {
+      console.error(`Error occurred while removing an account: ${e}`);
+    }
+  };
+  updateAccount = async (t) => {
+    try {
+      const e = await this.api.updateAccount(t);
+      i(() => {
+        const c = this.accounts.findIndex(
+          (s) => s.guid === e.guid
+        );
+        this.accounts.splice(c, 1, e), this.accounts = this.augmentAccounts(this.accounts);
+      });
+    } catch (e) {
+      console.error(`Error occurred while updating account: ${e}`);
+    }
+  };
+  updateAccountFiltering = async (t, e) => {
+    for (const c of t) {
+      const s = this.accounts.find((r) => r.guid === c);
+      if (s) {
+        s.is_excluded_from_accounts = e, s.is_excluded_from_budgets = e, s.is_excluded_from_cash_flow = e, s.is_excluded_from_debts = e, s.is_excluded_from_goals = e, s.is_excluded_from_investments = e, s.is_excluded_from_net_worth = e, s.is_excluded_from_spending = e, s.is_excluded_from_transactions = e, s.is_excluded_from_trends = e;
+        try {
+          this.updateAccount(s);
+        } catch (r) {
+          console.error(`Failed to update account ${c} (added):`, r);
+        }
+      }
+    }
+  };
+}
+export {
+  I as AccountStore
+};

package/dist/accounts/stores/UiStore/index.es.js

@@ -0,0 +1,15 @@
+import { makeAutoObservable as t } from "mobx";
+class o {
+  isLoading = !1;
+  selectedAccount = {};
+  selectedMember = {};
+  constructor() {
+    t(this);
+  }
+  setIsLoading = (e) => this.isLoading = e;
+  setSelectedAccount = (e) => this.selectedAccount = e;
+  setSelectedMember = (e) => this.selectedMember = e;
+}
+export {
+  o as UiStore
+};

package/dist/accounts/utils/AccountFields/index.es.js

@@ -0,0 +1,136 @@
+import { jsx as u } from "react/jsx-runtime";
+import { Icon as p, Text as c } from "@mxenabled/mxui";
+import { AccountType as d, AccountIcon as v, PropertyType as h, PropertyIcon as F } from "../../../common/types/Account/index.es.js";
+import { isManual as T, usesInterestRateField as D, isAccountLiability as A, usesCreditLimitField as O, usesOriginalBalanceField as g } from "../Accounts/index.es.js";
+import { FieldType as m } from "../../constants/Accounts/index.es.js";
+import { formatCurrency as _, isValidNumber as b, formatPercentage as N, formatOrdinal as S } from "../../../common/utils/NumberFormatting/index.es.js";
+import { buildDynamicCopy as i } from "../../../common/utils/Localization/index.es.js";
+import { formatDate as o, DATE_FORMATS_INTL as f } from "../../../common/constants/DateFormats/index.es.js";
+const x = (l, e) => {
+  const r = [
+    {
+      event: "account_details_click_account_name",
+      label: e.account_name,
+      name: "user_name",
+      placeholder: i(e.enter_value, e.account_name),
+      type: m.Input,
+      validation: (a) => a ? "" : i(e.field_is_required, e.account_name),
+      valueFormatter: (a) => a
+    }
+  ];
+  if (T(l)) {
+    r.unshift({
+      label: e.account_balance,
+      name: "balance",
+      placeholder: i(e.enter_value, e.account_balance),
+      type: m.Currency,
+      valueFormatter: (t) => _(t, "0,0.00")
+    });
+    const a = Object.keys(d).filter((t) => Number(t)).map((t) => ({
+      label: e.account_types[t],
+      value: Number(t),
+      icon: /* @__PURE__ */ u(p, { name: v[t] })
+    }));
+    r.push({
+      label: e.account_type,
+      name: "account_type",
+      options: a,
+      placeholder: i(e.select_value, e.account_type),
+      type: m.Select,
+      valueFormatter: (t) => a.find((n) => n.value === t)?.label
+    });
+  }
+  if (l.account_type === d.PROPERTY) {
+    const a = Object.keys(h).filter((t) => Number(t)).map((t) => ({
+      label: e.property_types[t],
+      value: Number(t),
+      icon: /* @__PURE__ */ u(p, { name: F[t] })
+    }));
+    r.push({
+      label: e.property_type,
+      name: "property_type",
+      options: a,
+      placeholder: i(e.select_value, e.property_type),
+      type: m.Select,
+      valueFormatter: (t) => a.find((n) => n.value === t)?.label
+    });
+  }
+  if (D(l)) {
+    let a = e.interest_rate, t = "interest_rate";
+    l.is_manual || (typeof l.apr == "number" && (a = e.apr, t = "apr"), typeof l.apy == "number" && (a = e.apy, t = "apy")), r.push({
+      event: "account_details_click_interest_rate",
+      label: a,
+      name: t,
+      placeholder: i(e.enter_value, a),
+      type: m.Input,
+      validation: (n) => b(n) ? "" : e.error_amount_is_invalid,
+      valueFormatter: (n) => b(n) ? N(n / 100) : n
+    });
+  }
+  return A(l) && (r.push({
+    label: e.minimum_payment,
+    name: "minimum_payment",
+    placeholder: i(e.enter_value, e.minimum_payment),
+    type: m.Currency,
+    valueFormatter: (a) => _(a, "0,0.00")
+  }), l.payment_due_at ? r.push({
+    label: e.next_payment,
+    name: "payment_due_at",
+    type: m.Date,
+    valueFormatter: (a) => {
+      const t = typeof a == "number" ? new Date(a * 1e3) : a;
+      return o(t, f.MED_MONTH_SHORT_DAY_FULL_YEAR);
+    }
+  }) : r.push({
+    label: e.day_payment_due,
+    name: "day_payment_is_due",
+    placeholder: i(e.enter_value, e.day_payment_due),
+    type: m.Date,
+    valueFormatter: (a) => i(
+      e.day_of_every_month,
+      S(a <= 31 ? a : new Date(a).getDate())
+    )
+  })), O(l) && r.push({
+    label: e.credit_limit,
+    name: "credit_limit",
+    placeholder: i(e.enter_value, e.credit_limit),
+    type: m.Currency,
+    valueFormatter: (a) => _(a, "0,0.00")
+  }), g(l) && r.push({
+    label: e.original_balance,
+    minAmount: 1,
+    name: "original_balance",
+    placeholder: i(e.enter_value, e.original_balance),
+    type: m.Currency,
+    valueFormatter: (a) => _(a, "0,0.00")
+  }), r;
+}, E = (l, e) => {
+  let r = "", a = null, t = null, n = null, s = !1;
+  switch (l.account_type) {
+    case 1:
+    case 2: {
+      l.available_balance ? (r = e.available_balance, a = l.available_balance, t = l.available_balance ? e.current_balance : null, n = _(l.balance, "0,0.00"), s = !0) : (r = e.current_balance, a = l.balance);
+      break;
+    }
+    default:
+      if (r = e.current_balance, a = l.balance, l.minimum_payment && l.payment_due_at) {
+        const y = typeof l.payment_due_at == "number" ? new Date(l.payment_due_at * 1e3) : l.payment_due_at;
+        t = /* @__PURE__ */ u(c, { component: "strong", variant: "XSmall", children: i(
+          e.payment_due_on,
+          _(l.minimum_payment, "0,0.00"),
+          o(y, f.FULL_MONTH_DAY)
+        ) });
+      } else l.credit_limit && (t = e.available_credit, n = _(l.credit_limit, "0,0.00"));
+  }
+  return {
+    firstSubtitle: r,
+    firstValue: a,
+    secondSubtitle: t,
+    secondValue: n,
+    hasAvailableBalance: s
+  };
+};
+export {
+  E as getAccountBalanceDetails,
+  x as getAccountDetailFields
+};

package/dist/accounts/utils/Accounts/index.es.js

@@ -0,0 +1,9 @@
+import { AccountType as _ } from "../../../common/types/Account/index.es.js";
+const p = (t) => t && (t.account_type === _.CREDIT_CARD || t.account_type === _.LOAN || t.account_type === _.MORTGAGE || t.account_type === _.LINE_OF_CREDIT || t.account_type === _.CHECKING_LINE_OF_CREDIT), E = (t) => t.is_manual || !t.guid, y = (t) => t.account_type === _.LINE_OF_CREDIT || t.account_type === _.CREDIT_CARD || t.account_type === _.CHECKING_LINE_OF_CREDIT, C = (t) => t.account_type === _.SAVINGS || t.account_type === _.CHECKING || t.account_type === _.LINE_OF_CREDIT || t.account_type === _.CREDIT_CARD || t.account_type === _.LOAN || t.account_type === _.MORTGAGE, I = (t) => t.account_type === _.LOAN || t.account_type === _.MORTGAGE;
+export {
+  p as isAccountLiability,
+  E as isManual,
+  y as usesCreditLimitField,
+  C as usesInterestRateField,
+  I as usesOriginalBalanceField
+};

package/dist/accounts/utils/getConnectionMessages/index.es.js

@@ -0,0 +1,162 @@
+import { fromUnixTime as u } from "date-fns/fromUnixTime";
+import { isToday as r } from "date-fns/isToday";
+import { isYesterday as l } from "date-fns/isYesterday";
+import { ConnectionStatusEnums as i } from "../../../common/types/Account/index.es.js";
+import { buildDynamicCopy as c } from "../../../common/utils/Localization/index.es.js";
+import { formatDate as o, DATE_FORMATS_INTL as _ } from "../../../common/constants/DateFormats/index.es.js";
+const T = (n, e) => {
+  const { connection_messages: t } = e;
+  switch (n.connection_status) {
+    case i.CHALLENGED:
+      return {
+        cta: t.challenged_cta,
+        main: c(
+          t.challenged_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.challenged_connection_title
+      };
+    case i.CLOSED:
+      return {
+        main: t.closed_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.closed_connection_title
+      };
+    case i.DEGRADED:
+      return {
+        main: t.degraded_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.degraded_connection_title
+      };
+    case i.DELAYED:
+      return {
+        main: c(
+          t.delayed_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.delayed_connection_title
+      };
+    case i.DENIED:
+      return {
+        cta: t.denied_cta,
+        main: c(
+          t.denied_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.denied_connection_title
+      };
+    case i.DISABLED:
+      return {
+        main: t.disabled_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.disabled_connection_title
+      };
+    case i.DISCONNECTED:
+      return {
+        main: c(
+          t.disconnected_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.disconnected_connection_title
+      };
+    case i.DISCONTINUED:
+      return {
+        main: t.discontinued_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.discontinued_connection_title
+      };
+    case i.EXPIRED:
+      return {
+        cta: t.expired_cta,
+        main: t.expired_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.expired_connection_title
+      };
+    case i.FAILED:
+      return {
+        main: c(
+          t.failed_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.failed_connection_title
+      };
+    case i.IMPAIRED:
+      return {
+        cta: t.impaired_cta,
+        main: c(
+          t.impaired_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.impaired_connection_title
+      };
+    case i.IMPEDED:
+      return {
+        main: c(
+          t.impeded_connection_description,
+          n.name,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.impeded_connection_title
+      };
+    case i.IMPORTED:
+      return {
+        cta: t.imported_cta,
+        main: c(
+          t.imported_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.imported_connection_title
+      };
+    case i.LOCKED:
+      return {
+        cta: t.locked_cta,
+        main: c(
+          t.locked_connection_description,
+          n.name
+        ),
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.locked_connection_title
+      };
+    case i.PREVENTED:
+      return {
+        cta: t.prevented_cta,
+        main: t.prevented_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.prevented_connection_title
+      };
+    case i.REJECTED:
+      return {
+        cta: t.rejected_cta,
+        main: t.rejected_connection_description,
+        statusName: e.connection_statuses[n.connection_status],
+        title: t.rejected_connection_title
+      };
+    default: {
+      const d = () => {
+        const s = n.successfully_aggregated_at ? u(n.successfully_aggregated_at) : void 0, a = s && o(s, _.TIME_STAMP_HOUR_MINUTE);
+        if (a)
+          return r(s) ? c(e.last_updated_at, e.today, a) : l(s) ? c(e.last_updated_at, e.yesterday, a) : c(
+            e.last_updated_at,
+            o(s, _.MONTH_DAY_YEAR),
+            a
+          );
+      };
+      return {
+        statusName: e.connection_statuses[6],
+        // Connected
+        title: d()
+      };
+    }
+  }
+};
+export {
+  T as getConnectionMessages
+};