appmax-client-vue3 5.0.2 → 5.0.3

package/dist/WithdrawBalanceStore-CQg7amrj.js

@@ -0,0 +1,504 @@
+import { ab as defineComponent, z as reactive, o as onMounted, A as watch, v as createBlock, k as createCommentVNode, h as openBlock, T as Teleport, j as createBaseVNode, n as normalizeClass, S as normalizeStyle, a6 as renderSlot, l as unref, y, w as withCtx, m as createTextVNode, t as toDisplayString, H as f, _ as _export_sfc, g as createElementBlock, r as ref, i as createVNode, $, B as BANK_ACCOUNT_ROUTE_NAMES, bO as useMediaQuery, e as computed, bK as withdrawCompanyService, c as useRouter, b as useRoute, ar as resolveDynamicComponent, F as Fragment, ae as formatFloatMoney, bN as toFloat, G as ApiService, az as toRefs, bQ as createDebounce, bI as CanceledError, L as nextTick } from "./main-Cykj4Wra.js";
+import { A as AmCardV3 } from "./AmCardV3-PfscHbHM.js";
+import { b as WithdrawDropdownContainer, A as AmLabelAndValue, _ as _sfc_main$6, C as CompanyDropdown } from "./WithdrawPermissionGuard-BYcwLoVl.js";
+import { u as useWithdrawCompanyStore, c as companyState } from "./WithdrawCompanyStore-D1LMIFjS.js";
+import { u as useWithdrawBankAccountStore, b as bankAccountState } from "./WithdrawBankAccountStore-DX-jevJk.js";
+import { B as BalanceType, w as withdrawCalculateService } from "./index-CfW5_MvI.js";
+const _hoisted_1$4 = { class: "am-modal-v3" };
+const _hoisted_2$2 = { class: "flex justify-between items-center mb-4" };
+const __default__$4 = { name: "AmModalV3" };
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  ...__default__$4,
+  props: {
+    modelValue: { type: Boolean, default: true },
+    title: {},
+    noCloseable: { type: Boolean, default: false },
+    dataTestPrefix: { default: "modal" },
+    fullHeightOnMobile: { type: Boolean },
+    maxWidth: { default: 500 }
+  },
+  emits: ["update:modelValue", "close"],
+  setup(__props, { emit: __emit }) {
+    const delay = (ms = 100) => new Promise((resolve) => setTimeout(resolve, ms));
+    const props = __props;
+    const emit = __emit;
+    const state = reactive({
+      open: false,
+      show: false,
+      pulse: false
+    });
+    const open = async () => {
+      emit("update:modelValue", true);
+      state.open = true;
+      await delay(0);
+      state.show = true;
+    };
+    const close = async () => {
+      state.show = false;
+      await delay(100);
+      emit("update:modelValue", false);
+      state.open = false;
+      emit("close");
+    };
+    const setIsOpened = (newValue) => {
+      if (state.open === newValue) return;
+      newValue ? open() : close();
+    };
+    const handlePulse = async () => {
+      state.pulse = true;
+      await delay();
+      state.pulse = false;
+    };
+    const handleClose = () => {
+      if (props.noCloseable) {
+        handlePulse();
+        return;
+      }
+      setIsOpened(false);
+    };
+    onMounted(() => {
+      setIsOpened(props.modelValue);
+    });
+    watch(() => props.modelValue, setIsOpened);
+    return (_ctx, _cache) => {
+      return state.open ? (openBlock(), createBlock(Teleport, {
+        key: 0,
+        to: "body"
+      }, [
+        createBaseVNode("div", _hoisted_1$4, [
+          createBaseVNode("div", {
+            class: normalizeClass(["am-modal-v3__overlay", { "am-modal-v3__overlay--is-opened": state.show }]),
+            onClick: handleClose
+          }, null, 2),
+          createBaseVNode("div", {
+            class: normalizeClass(["am-modal-v3__content", {
+              "am-modal-v3__content--is-opened": state.show,
+              "am-modal-v3__content--is-pulse": state.pulse,
+              "am-modal-v3__content--full-height-on-mobile": props.fullHeightOnMobile
+            }]),
+            style: normalizeStyle({ maxWidth: `${_ctx.maxWidth}px` })
+          }, [
+            createBaseVNode("div", _hoisted_2$2, [
+              _ctx.$slots.title ? renderSlot(_ctx.$slots, "title", { key: 0 }, void 0, true) : (openBlock(), createBlock(unref(y), {
+                key: 1,
+                variant: "title",
+                size: "small",
+                "data-test": `${_ctx.dataTestPrefix}-title`
+              }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(_ctx.title), 1)
+                ]),
+                _: 1
+              }, 8, ["data-test"])),
+              !_ctx.noCloseable ? (openBlock(), createBlock(unref(f), {
+                key: 2,
+                icon: "close",
+                "data-test": `${_ctx.dataTestPrefix}-close-button`,
+                onClick: handleClose
+              }, null, 8, ["data-test"])) : createCommentVNode("", true)
+            ]),
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ], 6)
+        ])
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+const AmModalV3 = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-f1626dc5"]]);
+const _sfc_main$4 = { name: "AmDivider" };
+const _hoisted_1$3 = { class: "am-divider" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("hr", _hoisted_1$3);
+}
+const AmDivider = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render], ["__scopeId", "data-v-b44d0231"]]);
+const _hoisted_1$2 = ["aria-hidden"];
+const _hoisted_2$1 = { class: "withdraw-extract-accordion__inner-content" };
+const _hoisted_3 = { class: "w-full flex justify-center" };
+const __default__$3 = { name: "WithdrawExtractAccordion" };
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  ...__default__$3,
+  setup(__props) {
+    const { openedAcordion } = useWithdrawCompanyStore();
+    const hidden = ref(true);
+    const toggleAccordion = () => {
+      openedAcordion.value = !openedAcordion.value;
+      hidden.value = !hidden.value;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(AmCardV3, {
+        class: "withdraw-extract-accordion",
+        "data-test": "withdraw-accordion"
+      }, {
+        default: withCtx(() => [
+          createBaseVNode("div", {
+            class: "withdraw-extract-accordion__content",
+            "aria-hidden": hidden.value
+          }, [
+            createBaseVNode("div", null, [
+              createBaseVNode("div", _hoisted_2$1, [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ])
+            ])
+          ], 8, _hoisted_1$2),
+          createBaseVNode("div", _hoisted_3, [
+            createVNode(unref($), {
+              size: "small",
+              text: "",
+              "data-test": "withdraw-toggle-accordion-button",
+              icon: hidden.value ? "expand_more" : "expand_less",
+              "icon-pos": "right",
+              label: hidden.value ? _ctx.$t("withdraw_v3.accordion.show") : _ctx.$t("withdraw_v3.accordion.hide"),
+              onClick: toggleAccordion
+            }, null, 8, ["icon", "label"])
+          ])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const WithdrawExtractAccordion = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-797d625c"]]);
+const _hoisted_1$1 = { class: "bank-account-empty-state" };
+const __default__$2 = { name: "BankAccountEmptyState" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...__default__$2,
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        createVNode(unref($), {
+          class: "bank-account-empty-state__button",
+          "data-test": "add-bank-account-button",
+          text: "",
+          size: "small",
+          to: { name: unref(BANK_ACCOUNT_ROUTE_NAMES).HOME },
+          icon: "add",
+          label: _ctx.$t("withdraw_v3.bank-account.add")
+        }, null, 8, ["to", "label"])
+      ]);
+    };
+  }
+});
+const BankAccountEmptyState = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-9c92b0d1"]]);
+const _hoisted_1 = {
+  key: 0,
+  class: "flex"
+};
+const _hoisted_2 = {
+  key: 2,
+  class: "bank-account-dropdown__group"
+};
+const __default__$1 = { name: "BankAccountDropdown" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...__default__$1,
+  setup(__props) {
+    const showAccordion = useMediaQuery("(max-width: 640px)");
+    const companyData = ref();
+    const isCompanyDataLoading = ref(false);
+    const shouldShowCrossborderBankAccountCreate = computed(() => {
+      if (!companyData.value) {
+        return false;
+      }
+      return withdrawCompanyService.isCompanyCrossBorder(companyData.value);
+    });
+    const router = useRouter();
+    const route = useRoute();
+    const createNewBankAccountForCrossBorder = () => {
+      router.push({ name: BANK_ACCOUNT_ROUTE_NAMES["CROSSBORDER_NEW"], query: route.query });
+    };
+    const getCompanyData = async () => {
+      isCompanyDataLoading.value = true;
+      const { selected: selected2 } = await withdrawCompanyService.getAll();
+      companyData.value = selected2;
+      isCompanyDataLoading.value = false;
+    };
+    const { isLoading: isLoading2, isEmpty, options, selected, showOptions, setBankAccount } = useWithdrawBankAccountStore();
+    onMounted(getCompanyData);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(unref(showAccordion) ? WithdrawExtractAccordion : WithdrawDropdownContainer), { class: "bank-account-dropdown" }, {
+        default: withCtx(() => {
+          var _a, _b, _c, _d;
+          return [
+            shouldShowCrossborderBankAccountCreate.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
+              createVNode(unref($), {
+                "data-test": `create-new-company-button`,
+                loading: isCompanyDataLoading.value,
+                icon: "chevron_right",
+                label: _ctx.$t("withdraw_v3.bank-account.crossborder.register"),
+                size: "small",
+                "icon-pos": "right",
+                text: "",
+                onClick: createNewBankAccountForCrossBorder
+              }, null, 8, ["loading", "label"])
+            ])) : !unref(isLoading2) && unref(isEmpty) ? (openBlock(), createBlock(AmLabelAndValue, {
+              key: 1,
+              class: "bank-account-dropdown__empty",
+              "data-test-prefix": "empty-bank-account",
+              label: _ctx.$t("withdraw_v3.bank-account.label"),
+              value: _ctx.$t("withdraw_v3.bank-account.empty")
+            }, null, 8, ["label", "value"])) : (openBlock(), createElementBlock("div", _hoisted_2, [
+              createVNode(AmLabelAndValue, {
+                class: "bank-account-dropdown__item",
+                "data-test-prefix": "pix-key",
+                "is-loading": unref(isLoading2),
+                label: _ctx.$t("withdraw_v3.pix.key"),
+                value: (_a = unref(selected)) == null ? void 0 : _a.pix.key
+              }, null, 8, ["is-loading", "label", "value"]),
+              createVNode(AmLabelAndValue, {
+                class: "bank-account-dropdown__item",
+                "data-test-prefix": "account-type",
+                "is-loading": unref(isLoading2),
+                label: _ctx.$t("withdraw_v3.bank-account.type"),
+                value: (_b = unref(selected)) == null ? void 0 : _b.account.type
+              }, null, 8, ["is-loading", "label", "value"]),
+              createVNode(AmLabelAndValue, {
+                class: "bank-account-dropdown__item",
+                "data-test-prefix": "document-number",
+                "is-loading": unref(isLoading2),
+                label: ((_c = unref(selected)) == null ? void 0 : _c.document.type) || _ctx.$t("withdraw_v3.document.label"),
+                value: (_d = unref(selected)) == null ? void 0 : _d.document.number
+              }, null, 8, ["is-loading", "label", "value"])
+            ])),
+            !unref(isLoading2) ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
+              unref(isEmpty) ? (openBlock(), createBlock(BankAccountEmptyState, { key: 0 })) : unref(showOptions) ? (openBlock(), createBlock(_sfc_main$6, {
+                key: 1,
+                class: "bank-account-dropdown__trigger",
+                "data-test-prefix": "bank-account-dropdown",
+                "button-text": _ctx.$t("withdraw_v3.bank-account.button"),
+                options: unref(options),
+                "model-value": unref(selected),
+                "onUpdate:modelValue": unref(setBankAccount)
+              }, null, 8, ["button-text", "options", "model-value", "onUpdate:modelValue"])) : createCommentVNode("", true)
+            ], 64)) : createCommentVNode("", true),
+            unref(showAccordion) ? (openBlock(), createBlock(AmDivider, {
+              key: 4,
+              class: "bank-account-dropdown__divider"
+            })) : createCommentVNode("", true)
+          ];
+        }),
+        _: 1
+      });
+    };
+  }
+});
+const BankAccountDropdown = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-74f2f232"]]);
+const __default__ = { name: "WithdrawCompanySelector" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(AmCardV3, { class: "withdraw-company-selector" }, {
+        default: withCtx(() => [
+          createVNode(CompanyDropdown),
+          _cache[0] || (_cache[0] = createBaseVNode("hr", null, null, -1)),
+          createVNode(BankAccountDropdown)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const WithdrawCompanySelector = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-707746a8"]]);
+const DEFAULT_INTERNATIONAL_RESPONSE = {
+  availableGrossValue: 0,
+  currency: "USD"
+};
+class WithdrawBalanceService {
+  constructor(apiService, calculateService) {
+    this.apiService = apiService;
+    this.calculateService = calculateService;
+  }
+  async getByCompanyId(companyId, balanceType, bankAccountId) {
+    const result = balanceType === BalanceType.INTERNATIONAL ? await this.internationalBalance(companyId) : await this.nationalBalance(companyId, balanceType);
+    const calculatedData = await this.getCalculateData(
+      result.availableGrossValue,
+      companyId,
+      balanceType,
+      bankAccountId
+    );
+    return this.serialize(result, calculatedData);
+  }
+  serialize(balance, calculatedData) {
+    const netValue = (calculatedData == null ? void 0 : calculatedData.netValue) || 0;
+    const hasAvailableValue = netValue > 0;
+    const availableNetValue = hasAvailableValue ? netValue : 0;
+    return {
+      ...balance,
+      availableNetValue,
+      hasAvailableValue,
+      calculatedData,
+      formatedAvailableNetValue: formatFloatMoney(availableNetValue, balance.currency),
+      formatedAvailableGrossValue: formatFloatMoney(balance.availableGrossValue, balance.currency)
+    };
+  }
+  async nationalBalance(companyId, balanceType) {
+    const url = `/balance/companies/balance-values?company_id=${companyId}&type=${balanceType}`;
+    const { data } = await this.apiService.get(url);
+    return { availableGrossValue: toFloat(data.available), currency: "BRL" };
+  }
+  async internationalBalance(companyId) {
+    const url = `/api/balance/international/companies/available?company_id=${companyId}`;
+    const { data } = await this.apiService.get(url);
+    if (!Array.isArray(data) || data.length === 0) return DEFAULT_INTERNATIONAL_RESPONSE;
+    const balance = data.find((item) => item.currency === DEFAULT_INTERNATIONAL_RESPONSE.currency);
+    if (!balance || typeof balance.total !== "number") return DEFAULT_INTERNATIONAL_RESPONSE;
+    return {
+      availableGrossValue: toFloat(balance.total),
+      currency: DEFAULT_INTERNATIONAL_RESPONSE.currency
+    };
+  }
+  async getCalculateData(availableGrossValue, companyId, balanceType, bankAccountId) {
+    return this.calculateService.getValues({
+      availableValue: availableGrossValue,
+      value: availableGrossValue,
+      companyId,
+      balanceType,
+      bankAccountId
+    });
+  }
+}
+const withdrawBalanceService = new WithdrawBalanceService(ApiService, withdrawCalculateService);
+const calculateState = reactive({
+  isLoading: true,
+  error: false,
+  inputValue: 0,
+  data: null
+});
+const setCalculateState = (state) => {
+  Object.assign(calculateState, state);
+};
+const debounce = createDebounce((value) => {
+  if (value === calculateState.inputValue) {
+    calculateState.isLoading = false;
+    return;
+  }
+  calculateState.inputValue = value;
+});
+const setInputValue = (value) => {
+  if (balanceState.isLoading) {
+    calculateState.inputValue = value;
+    return;
+  }
+  calculateState.isLoading = true;
+  debounce(value);
+};
+const resetState = () => {
+  calculateState.isLoading = true;
+  calculateState.data = null;
+};
+const getValues = async () => {
+  var _a, _b;
+  if (balanceState.isLoading) return;
+  const companyId = (_a = companyState.selected) == null ? void 0 : _a.id;
+  const availableValue = ((_b = balanceState.data) == null ? void 0 : _b.availableNetValue) || 0;
+  const value = calculateState.inputValue;
+  if (!companyId || availableValue <= 0 || !bankAccountState.selected) return;
+  try {
+    calculateState.isLoading = true;
+    calculateState.data = null;
+    const payload = {
+      companyId,
+      value,
+      availableValue,
+      balanceType: balanceState.balanceType,
+      bankAccountId: bankAccountState.selected.id
+    };
+    calculateState.data = await withdrawCalculateService.getValues(payload);
+    calculateState.error = false;
+    calculateState.isLoading = false;
+  } catch (error) {
+    if (error instanceof CanceledError) return;
+    calculateState.error = true;
+    calculateState.isLoading = false;
+  }
+};
+watch(() => calculateState.inputValue, getValues);
+watch(() => {
+  var _a;
+  return (_a = bankAccountState.selected) == null ? void 0 : _a.id;
+}, getValues);
+watch(() => {
+  var _a;
+  return (_a = companyState.selected) == null ? void 0 : _a.id;
+}, resetState);
+const isLoading = computed(() => calculateState.isLoading || balanceState.isLoading);
+const shouldConfirm = computed(() => {
+  var _a;
+  return !!((_a = calculateState.data) == null ? void 0 : _a.shouldConfirm) && !!bankAccountState.selected && !isLoading.value && !calculateState.error;
+});
+const isInputDisabled = computed(() => {
+  var _a;
+  return !((_a = balanceState.data) == null ? void 0 : _a.hasAvailableValue) || balanceState.isLoading || bankAccountState.isEmpty;
+});
+const hasInputError = computed(() => !!inputTextError.value);
+const inputTextError = computed(() => {
+  var _a;
+  const error = (_a = calculateState.data) == null ? void 0 : _a.error;
+  if (isLoading.value || !error) return "";
+  return error;
+});
+const showFreeWithdrawTaxMax = computed(() => {
+  var _a, _b;
+  return Boolean(((_a = bankAccountState.selected) == null ? void 0 : _a.isMaxAccount) && ((_b = calculateState.data) == null ? void 0 : _b.tax) === 0);
+});
+const useWithdrawCalculateStore = () => ({
+  ...toRefs(calculateState),
+  isLoading,
+  isInputDisabled,
+  inputTextError,
+  hasInputError,
+  setInputValue,
+  shouldConfirm,
+  showFreeWithdrawTaxMax
+});
+const balanceState = reactive({
+  isLoading: true,
+  error: false,
+  balanceType: BalanceType.WITHDRAW,
+  data: null
+});
+const useWithdrawBalanceStore = () => {
+  const router = useRouter();
+  const redirectToWithdraw = () => router.replace("/v2/client/integration/withdraw");
+  const getBalanceByType = async (balanceType) => {
+    var _a, _b;
+    const companyId = (_a = companyState.selected) == null ? void 0 : _a.id;
+    if (!companyId) return;
+    try {
+      setCalculateState({ data: null, inputValue: 0, isLoading: true });
+      balanceState.isLoading = true;
+      balanceState.error = false;
+      balanceState.data = null;
+      balanceState.balanceType = balanceType;
+      const { calculatedData, ...balance } = await withdrawBalanceService.getByCompanyId(
+        companyId,
+        balanceType,
+        (_b = bankAccountState.selected) == null ? void 0 : _b.id
+      );
+      balanceState.data = balance;
+      setCalculateState({ data: calculatedData, inputValue: balance.availableNetValue });
+      if (!balanceState.data.hasAvailableValue) {
+        return redirectToWithdraw();
+      }
+      await nextTick();
+      balanceState.isLoading = false;
+      setCalculateState({ isLoading: false });
+    } catch (error) {
+      balanceState.error = true;
+      balanceState.isLoading = false;
+    }
+  };
+  const isAdvance = computed(() => balanceState.balanceType === BalanceType.ADVANCE);
+  const isInternational = computed(() => balanceState.balanceType === BalanceType.INTERNATIONAL);
+  const currency = computed(() => isInternational.value ? "USD" : "BRL");
+  return { ...toRefs(balanceState), getBalanceByType, isAdvance, isInternational, currency };
+};
+export {
+  AmModalV3 as A,
+  WithdrawExtractAccordion as W,
+  WithdrawCompanySelector as a,
+  useWithdrawCalculateStore as b,
+  AmDivider as c,
+  calculateState as d,
+  balanceState as e,
+  useWithdrawBalanceStore as u
+};

package/dist/WithdrawBankAccountStore-DX-jevJk.js

@@ -0,0 +1,130 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { ck as formatCNPJ, bH as capitalize, G as ApiService, e as computed, az as toRefs, z as reactive, A as watch } from "./main-Cykj4Wra.js";
+import { c as companyState } from "./WithdrawCompanyStore-D1LMIFjS.js";
+class WithdrawBankAccountService {
+  constructor(apiService) {
+    __publicField(this, "cache", {});
+    this.apiService = apiService;
+  }
+  async getByCompanyId(companyId) {
+    if (!this.cache[companyId]) {
+      this.cache[companyId] = await this.getData(companyId);
+    }
+    return this.cache[companyId];
+  }
+  async getData(companyId) {
+    const route = `/balance/companies/bank-list`;
+    const params = { company_id: companyId };
+    const { data } = await this.apiService.get(route, { params });
+    const bankAccounts = this.serialize(data);
+    return {
+      options: bankAccounts,
+      selected: this.getDefaultBankAccount(bankAccounts),
+      hasMaxAccount: bankAccounts.some((account) => account.isMaxAccount)
+    };
+  }
+  serialize(data) {
+    const [firstItem] = data;
+    if (!firstItem) return [];
+    return Object.values(firstItem).map((bankAccount) => ({
+      id: bankAccount.id,
+      // option
+      label: this.getLabelName(bankAccount),
+      value: bankAccount.id,
+      // data
+      isDefault: this.isDefaultAccount(bankAccount),
+      isMaxAccount: !!bankAccount.is_max_account,
+      hasFreeWithdrawTax: !!bankAccount.has_free_withdraw_tax,
+      account: {
+        name: this.getAccountName(bankAccount),
+        number: bankAccount.account,
+        type: this.getTypeAccount(bankAccount)
+      },
+      pix: {
+        has: this.isPixAccount(bankAccount),
+        key: bankAccount.pix_key,
+        type: bankAccount.pix_key_type
+      },
+      document: {
+        type: bankAccount.document_number_type,
+        number: formatCNPJ(bankAccount.cnpj)
+        // or cpf
+      }
+    }));
+  }
+  getDefaultBankAccount(bankAccounts) {
+    return bankAccounts.find((account) => account.isDefault) || bankAccounts[0] || null;
+  }
+  getTypeAccount(bankAccount) {
+    if (this.isPixAccount(bankAccount)) return "Pix";
+    return bankAccount.profile || "-";
+  }
+  getLabelName(bankAccount) {
+    if (this.isPixAccount(bankAccount)) {
+      return `${bankAccount.profile} | ${bankAccount.pix_key_type.toUpperCase()} | ${bankAccount.pix_key_formatted}`;
+    }
+    return bankAccount.bank_alias_name || bankAccount.profile;
+  }
+  getAccountName(bankAccount) {
+    const name = bankAccount.bank_alias_name || bankAccount.bank_name || bankAccount.user_name || bankAccount.profile;
+    return capitalize(name);
+  }
+  isPixAccount(bankAccount) {
+    return bankAccount.profile === "Conta Pix";
+  }
+  isDefaultAccount(bankAccount) {
+    return bankAccount.account_type === "Padrão";
+  }
+}
+const withdrawBankAccountService = new WithdrawBankAccountService(ApiService);
+const bankAccountState = reactive({
+  isLoading: true,
+  error: false,
+  options: [],
+  selected: null,
+  showOptions: false,
+  isEmpty: true,
+  hasMaxAccount: false
+});
+const setBankAccount = (bankAccount) => {
+  bankAccountState.selected = bankAccount;
+};
+const resetState = () => {
+  bankAccountState.isLoading = true;
+  bankAccountState.error = false;
+  bankAccountState.showOptions = false;
+  bankAccountState.isEmpty = true;
+  bankAccountState.options = [];
+};
+const getBankAccounts = async (companyId) => {
+  if (!companyId) return;
+  try {
+    resetState();
+    const response = await withdrawBankAccountService.getByCompanyId(companyId);
+    bankAccountState.options = response.options;
+    bankAccountState.hasMaxAccount = response.hasMaxAccount;
+    bankAccountState.selected = response.selected;
+    bankAccountState.showOptions = response.options.length > 1;
+    bankAccountState.isEmpty = !response.options.length;
+  } catch {
+    bankAccountState.error = true;
+  } finally {
+    bankAccountState.isLoading = false;
+  }
+};
+watch(() => {
+  var _a;
+  return (_a = companyState.selected) == null ? void 0 : _a.id;
+}, getBankAccounts);
+const isLoading = computed(() => companyState.isLoading || bankAccountState.isLoading);
+const useWithdrawBankAccountStore = () => ({
+  ...toRefs(bankAccountState),
+  isLoading,
+  setBankAccount
+});
+export {
+  bankAccountState as b,
+  useWithdrawBankAccountStore as u
+};