Skip to content

Open source personal finance application

refactor(wallets): extract pure grouping logic and add tests

Ilya Komichevcffac018cf82
diff --git a/app/components/wallets/grouping.test.ts b/app/components/wallets/grouping.test.ts
new file mode 100644
index 00000000..c955daaf
--- /dev/null
+++ b/app/components/wallets/grouping.test.ts
@@ -0,0 +1,256 @@
+import { describe, expect, it } from 'vitest'
+
+import type { WalletsToggleMap } from '~/components/wallets/grouping'
+import type { WalletItemComputed } from '~/components/wallets/types'
+
+import { applyToggle, applyToggleAll, buildWalletGroups, computeToggleStatus, groupWalletsByProperty } from '~/components/wallets/grouping'
+
+function wallet(overrides: Partial<WalletItemComputed> & Pick<WalletItemComputed, 'amount' | 'currency' | 'type'>): WalletItemComputed {
+ return {
+ color: 'blue',
+ desc: '',
+ isArchived: false,
+ isExcludeInTotal: false,
+ isWithdrawal: false,
+ name: 'Test',
+ order: 0,
+ updatedAt: 0,
+ ...overrides,
+ } as WalletItemComputed
+}
+
+const wallets = {
+ cardRUB: wallet({ amount: 3000, currency: 'RUB', type: 'cashless' }),
+ cardUSD: wallet({ amount: 500, currency: 'USD', type: 'cashless' }),
+ cashRUB: wallet({ amount: 5000, currency: 'RUB', type: 'cash' }),
+ cashUSD: wallet({ amount: 100, currency: 'USD', type: 'cash' }),
+ creditUSD: wallet({ amount: -200, creditLimit: 5000, currency: 'USD', type: 'credit' }),
+} as Record<string, WalletItemComputed>
+
+const allIds = Object.keys(wallets)
+
+describe('groupWalletsByProperty', () => {
+ it('groups by type', () => {
+ const result = groupWalletsByProperty(allIds, wallets, 'type')
+ expect(Object.keys(result).sort()).toEqual(['cash', 'cashless', 'credit'])
+ expect(result.cashless).toEqual(['cardRUB', 'cardUSD'])
+ expect(result.cash).toEqual(['cashRUB', 'cashUSD'])
+ expect(result.credit).toEqual(['creditUSD'])
+ })
+
+ it('groups by currency', () => {
+ const result = groupWalletsByProperty(allIds, wallets, 'currency')
+ expect(Object.keys(result).sort()).toEqual(['RUB', 'USD'])
+ expect(result.RUB).toEqual(['cardRUB', 'cashRUB'])
+ expect(result.USD).toEqual(['cardUSD', 'cashUSD', 'creditUSD'])
+ })
+
+ it('handles missing wallet IDs gracefully', () => {
+ const result = groupWalletsByProperty(['missing', 'cashUSD'], wallets, 'type')
+ expect(result['']).toEqual(['missing'])
+ expect(result.cash).toEqual(['cashUSD'])
+ })
+
+ it('returns empty groups for empty IDs', () => {
+ const result = groupWalletsByProperty([], wallets, 'type')
+ expect(Object.keys(result)).toEqual([])
+ })
+})
+
+describe('buildWalletGroups', () => {
+ it('returns false for groupedBy "none"', () => {
+ expect(buildWalletGroups(allIds, wallets, 'none', false)).toBe(false)
+ })
+
+ it('builds primary groups by type', () => {
+ const result = buildWalletGroups(allIds, wallets, 'type', false)
+ expect(result).not.toBe(false)
+ if (!result)
+ return
+
+ expect(result.cashless.ids).toEqual(['cardRUB', 'cardUSD'])
+ expect(result.cash.ids).toEqual(['cashRUB', 'cashUSD'])
+ expect(result.cash.groups).toEqual({})
+ })
+
+ it('builds primary groups by currency', () => {
+ const result = buildWalletGroups(allIds, wallets, 'currency', false)
+ if (!result)
+ return
+
+ expect(result.RUB.ids).toEqual(['cardRUB', 'cashRUB'])
+ expect(result.USD.ids).toEqual(['cardUSD', 'cashUSD', 'creditUSD'])
+ })
+
+ it('builds secondary groups: type → currency', () => {
+ const result = buildWalletGroups(allIds, wallets, 'type', true)
+ if (!result)
+ return
+
+ expect(result.cash.groups).toBeDefined()
+ expect(result.cash.groups!.RUB).toEqual(['cashRUB'])
+ expect(result.cash.groups!.USD).toEqual(['cashUSD'])
+ })
+
+ it('builds secondary groups: currency → type', () => {
+ const result = buildWalletGroups(allIds, wallets, 'currency', true)
+ if (!result)
+ return
+
+ expect(result.USD.groups!.cash).toEqual(['cashUSD'])
+ expect(result.USD.groups!.cashless).toEqual(['cardUSD'])
+ expect(result.USD.groups!.credit).toEqual(['creditUSD'])
+ })
+})
+
+describe('computeToggleStatus', () => {
+ it('returns all false for groupedBy "none"', () => {
+ const result = computeToggleStatus({}, 'none')
+ expect(result).toEqual({
+ isAllOpen: false,
+ isAllOpenInside: false,
+ isAnyOpen: false,
+ isAnyOpenInside: false,
+ })
+ })
+
+ it('returns all false for empty toggle map', () => {
+ const result = computeToggleStatus({}, 'type')
+ expect(result.isAllOpen).toBe(false)
+ expect(result.isAnyOpen).toBe(false)
+ })
+
+ it('detects all open', () => {
+ const map: WalletsToggleMap = {
+ type: {
+ cash: { show: true },
+ cashless: { show: true },
+ },
+ }
+ const result = computeToggleStatus(map, 'type')
+ expect(result.isAllOpen).toBe(true)
+ expect(result.isAnyOpen).toBe(true)
+ })
+
+ it('detects some open', () => {
+ const map: WalletsToggleMap = {
+ type: {
+ cash: { show: true },
+ cashless: { show: false },
+ },
+ }
+ const result = computeToggleStatus(map, 'type')
+ expect(result.isAllOpen).toBe(false)
+ expect(result.isAnyOpen).toBe(true)
+ })
+
+ it('detects secondary groups open', () => {
+ const map: WalletsToggleMap = {
+ type: {
+ cash: { groups: { RUB: true, USD: true }, show: true },
+ },
+ }
+ const result = computeToggleStatus(map, 'type')
+ expect(result.isAllOpenInside).toBe(true)
+ expect(result.isAnyOpenInside).toBe(true)
+ })
+})
+
+describe('applyToggle', () => {
+ it('toggles primary group from undefined to false', () => {
+ const result = applyToggle({}, 'type', 'cash')
+ expect(result.type!.cash.show).toBe(false)
+ })
+
+ it('toggles primary group from false to true', () => {
+ const map: WalletsToggleMap = { type: { cash: { show: false } } }
+ const result = applyToggle(map, 'type', 'cash')
+ expect(result.type!.cash.show).toBe(true)
+ })
+
+ it('toggles secondary group from undefined to false', () => {
+ const result = applyToggle({}, 'type', 'cash', 'RUB')
+ expect(result.type!.cash.groups!.RUB).toBe(false)
+ })
+
+ it('toggles secondary group from false to true', () => {
+ const map: WalletsToggleMap = { type: { cash: { groups: { RUB: false } } } }
+ const result = applyToggle(map, 'type', 'cash', 'RUB')
+ expect(result.type!.cash.groups!.RUB).toBe(true)
+ })
+
+ it('does nothing for groupedBy "none"', () => {
+ const map: WalletsToggleMap = {}
+ const result = applyToggle(map, 'none', 'cash')
+ expect(result).toEqual({})
+ })
+})
+
+describe('applyToggleAll', () => {
+ const grouped = {
+ cash: { groups: { RUB: ['cashRUB'], USD: ['cashUSD'] }, ids: ['cashRUB', 'cashUSD'] },
+ cashless: { groups: { RUB: ['cardRUB'], USD: ['cardUSD'] }, ids: ['cardRUB', 'cardUSD'] },
+ }
+
+ it('opens all primary groups when none are open', () => {
+ const status = { isAllOpen: false, isAllOpenInside: false, isAnyOpen: false, isAnyOpenInside: false }
+ const result = applyToggleAll({}, 'type', grouped, false, status)
+
+ expect(result.type!.cash.show).toBe(true)
+ expect(result.type!.cashless.show).toBe(true)
+ })
+
+ it('closes all primary groups when all are open', () => {
+ const map: WalletsToggleMap = {
+ type: {
+ cash: { show: true },
+ cashless: { show: true },
+ },
+ }
+ const status = { isAllOpen: true, isAllOpenInside: false, isAnyOpen: true, isAnyOpenInside: false }
+ const result = applyToggleAll(map, 'type', grouped, false, status)
+
+ expect(result.type!.cash.show).toBe(false)
+ expect(result.type!.cashless.show).toBe(false)
+ })
+
+ it('with secondary: opens secondary when primary already open', () => {
+ const map: WalletsToggleMap = {
+ type: {
+ cash: { groups: { RUB: false, USD: false }, show: true },
+ cashless: { groups: { RUB: false, USD: false }, show: true },
+ },
+ }
+ const status = { isAllOpen: true, isAllOpenInside: false, isAnyOpen: true, isAnyOpenInside: false }
+ const result = applyToggleAll(map, 'type', grouped, true, status)
+
+ expect(result.type!.cash.groups!.RUB).toBe(true)
+ expect(result.type!.cash.groups!.USD).toBe(true)
+ expect(result.type!.cashless.groups!.RUB).toBe(true)
+ })
+
+ it('with secondary: closes everything when all open', () => {
+ const map: WalletsToggleMap = {
+ type: {
+ cash: { groups: { RUB: true, USD: true }, show: true },
+ cashless: { groups: { RUB: true, USD: true }, show: true },
+ },
+ }
+ const status = { isAllOpen: true, isAllOpenInside: true, isAnyOpen: true, isAnyOpenInside: true }
+ const result = applyToggleAll(map, 'type', grouped, true, status)
+
+ expect(result.type!.cash.show).toBe(false)
+ expect(result.type!.cash.groups!.RUB).toBe(false)
+ expect(result.type!.cashless.show).toBe(false)
+ })
+
+ it('does nothing for groupedBy "none"', () => {
+ const result = applyToggleAll({}, 'none', grouped, false, {
+ isAllOpen: false,
+ isAllOpenInside: false,
+ isAnyOpen: false,
+ isAnyOpenInside: false,
+ })
+ expect(result).toEqual({})
+ })
+})
diff --git a/app/components/wallets/grouping.ts b/app/components/wallets/grouping.ts
new file mode 100644
index 00000000..c48242a0
--- /dev/null
+++ b/app/components/wallets/grouping.ts
@@ -0,0 +1,167 @@
+import type { WalletId, WalletItem, WalletItemComputed, WalletsGroupedBy } from '~/components/wallets/types'
+
+type WalletsGroupedByExcludedNone = Exclude<WalletsGroupedBy, 'none'>
+
+export type WalletGroup = {
+ groups?: Record<string, WalletId[]>
+ ids: WalletId[]
+}
+export type GroupedWallets = Record<string, WalletGroup>
+
+export type GroupToggleState = {
+ groups?: Record<string, boolean>
+ show?: boolean
+}
+type ToggleMapByGroup = Record<string, GroupToggleState>
+export type WalletsToggleMap = Partial<Record<WalletsGroupedByExcludedNone, ToggleMapByGroup>>
+
+export type ToggleStatus = {
+ isAllOpen: boolean
+ isAllOpenInside: boolean
+ isAnyOpen: boolean
+ isAnyOpenInside: boolean
+}
+
+const groupingStrategies = {
+ currency: { primary: 'currency', secondary: 'type' },
+ type: { primary: 'type', secondary: 'currency' },
+} as const
+
+export function groupWalletsByProperty(
+ ids: WalletId[],
+ wallets: Record<WalletId, WalletItemComputed>,
+ property: keyof WalletItem,
+): Record<string, WalletId[]> {
+ return Object.groupBy(ids, (id) => {
+ const wallet = wallets[id]
+ return wallet ? String(wallet[property] || '') : ''
+ }) as Record<string, WalletId[]>
+}
+
+export function buildWalletGroups(
+ ids: WalletId[],
+ wallets: Record<WalletId, WalletItemComputed>,
+ groupedBy: WalletsGroupedBy,
+ useSecondary: boolean,
+): GroupedWallets | false {
+ if (groupedBy === 'none')
+ return false
+
+ const strategy = groupingStrategies[groupedBy as WalletsGroupedByExcludedNone]
+ if (!strategy)
+ return false
+
+ const primaryGrouped = groupWalletsByProperty(ids, wallets, strategy.primary)
+
+ if (!useSecondary) {
+ return Object.fromEntries(
+ Object.entries(primaryGrouped).map(([key, groupIds]) => [key, { groups: {}, ids: groupIds }]),
+ )
+ }
+
+ return Object.fromEntries(
+ Object.entries(primaryGrouped).map(([key, groupIds]) => [
+ key,
+ {
+ groups: groupWalletsByProperty(groupIds, wallets, strategy.secondary),
+ ids: groupIds,
+ },
+ ]),
+ )
+}
+
+export function computeToggleStatus(
+ toggleMap: WalletsToggleMap,
+ groupedBy: WalletsGroupedBy,
+): ToggleStatus {
+ if (groupedBy === 'none' || !toggleMap[groupedBy])
+ return { isAllOpen: false, isAllOpenInside: false, isAnyOpen: false, isAnyOpenInside: false }
+
+ const groups = toggleMap[groupedBy] || {}
+
+ return {
+ isAllOpen: Object.values(groups).every(group => !!group.show),
+ isAllOpenInside: Object.values(groups).every(group =>
+ Object.values(group.groups || {}).every(isOpen => !!isOpen),
+ ),
+ isAnyOpen: Object.values(groups).some(group => !!group.show),
+ isAnyOpenInside: Object.values(groups).some(group =>
+ Object.values(group.groups || {}).some(isOpen => !!isOpen),
+ ),
+ }
+}
+
+export function applyToggle(
+ toggleMap: WalletsToggleMap,
+ groupedBy: WalletsGroupedBy,
+ groupPrimary: string,
+ groupSecondary?: string,
+): WalletsToggleMap {
+ if (groupedBy === 'none')
+ return toggleMap
+
+ const result = { ...toggleMap }
+ result[groupedBy] ??= {}
+ result[groupedBy]![groupPrimary] ??= { groups: {} }
+
+ const primaryGroup = result[groupedBy]![groupPrimary]
+
+ if (groupSecondary) {
+ primaryGroup.groups ??= {}
+ const current = primaryGroup.groups[groupSecondary]
+ primaryGroup.groups[groupSecondary] = current === undefined ? false : !current
+ }
+ else {
+ primaryGroup.groups ??= {}
+ primaryGroup.show = primaryGroup.show === undefined ? false : !primaryGroup.show
+ }
+
+ return result
+}
+
+export function applyToggleAll(
+ toggleMap: WalletsToggleMap,
+ groupedBy: WalletsGroupedBy,
+ groupedWallets: GroupedWallets,
+ hasSecondary: boolean,
+ status: ToggleStatus,
+): WalletsToggleMap {
+ if (groupedBy === 'none')
+ return toggleMap
+
+ const result = { ...toggleMap }
+ result[groupedBy] ??= {}
+
+ const { isAllOpen, isAllOpenInside } = status
+ const newShow = !hasSecondary ? !isAllOpen : !(isAllOpen && isAllOpenInside)
+ const updateSecondary = hasSecondary && isAllOpen && !isAllOpenInside
+
+ for (const [groupPrimary, walletGroup] of Object.entries(groupedWallets)) {
+ const primaryGroup = result[groupedBy]![groupPrimary] || { groups: {} }
+
+ if (updateSecondary) {
+ const secondaryKeys = Object.keys(walletGroup.groups ?? {})
+ result[groupedBy]![groupPrimary] = {
+ ...primaryGroup,
+ groups: Object.fromEntries(secondaryKeys.map(k => [k, true])),
+ show: true,
+ }
+ }
+ else if (hasSecondary && !newShow) {
+ const secondaryKeys = Object.keys(walletGroup.groups ?? {})
+ result[groupedBy]![groupPrimary] = {
+ ...primaryGroup,
+ groups: Object.fromEntries(secondaryKeys.map(k => [k, false])),
+ show: false,
+ }
+ }
+ else {
+ result[groupedBy]![groupPrimary] = {
+ ...primaryGroup,
+ show: newShow,
+ }
+ }
+ }
+
+ return result
+}
diff --git a/app/components/wallets/page/List.vue b/app/components/wallets/page/List.vue
index 1f3ee226..6c576e83 100644
--- a/app/components/wallets/page/List.vue
+++ b/app/components/wallets/page/List.vue
@@ -8,12 +8,11 @@ import { useCurrenciesStore } from '~/components/currencies/useCurrenciesStore'
import { useTrnsStore } from '~/components/trns/useTrnsStore'
import { useUserStore } from '~/components/user/useUserStore'
import { useWalletContextMenu } from '~/components/wallets/useWalletContextMenu'
-import { useWalletsStore } from '~/components/wallets/useWalletsStore'
-import { showSuccessToast } from '~/composables/useStoreSync'
-
import { useWalletsCounts } from '~/components/wallets/useWalletsCounts'
import { useWalletsFilter } from '~/components/wallets/useWalletsFilter'
-import { useWalletsPageGrouping } from './useWalletsPageGrouping'
+import { useWalletsGrouping } from '~/components/wallets/useWalletsGrouping'
+import { useWalletsStore } from '~/components/wallets/useWalletsStore'
+import { showSuccessToast } from '~/composables/useStoreSync'
const { t } = useI18n()
const router = useRouter()
@@ -98,7 +97,7 @@ const {
toggleOpened,
typeGroupsStatus,
walletsToggledMap,
-} = useWalletsPageGrouping(selectedWalletsIds, groupedBy)
+} = useWalletsGrouping(selectedWalletsIds, groupedBy)
function toggleSecondaryGrouping() {
if (groupedBy.value === 'currency')
diff --git a/app/components/wallets/useWalletsGrouping.ts b/app/components/wallets/useWalletsGrouping.ts
new file mode 100644
index 00000000..e3deb837
--- /dev/null
+++ b/app/components/wallets/useWalletsGrouping.ts
@@ -0,0 +1,101 @@
+import type { ComputedRef, Ref } from 'vue'
+
+import { useStorage } from '@vueuse/core'
+
+import type { GroupedWallets, WalletsToggleMap } from '~/components/wallets/grouping'
+import type { WalletId, WalletsGroupedBy } from '~/components/wallets/types'
+
+import { applyToggle, applyToggleAll, buildWalletGroups, computeToggleStatus } from '~/components/wallets/grouping'
+import { useWalletsStore } from '~/components/wallets/useWalletsStore'
+
+export type { GroupedWallets }
+
+export function useWalletsGrouping(
+ selectedWalletsIds: ComputedRef<WalletId[]>,
+ groupedBy: Ref<WalletsGroupedBy>,
+) {
+ const { t } = useI18n()
+ const walletsStore = useWalletsStore()
+
+ const groupedBySecondary = useStorage('finapp-wallets-groupedBySecondary', {
+ currency: false,
+ type: false,
+ })
+
+ const walletsToggledMap = useStorage<WalletsToggleMap>('finapp-wallets-toggle-map', {} as WalletsToggleMap, localStorage, {
+ mergeDefaults: true,
+ })
+
+ const groupedWalletsWithIds = computed<GroupedWallets | false>(() => {
+ let useSecondary = false
+ if (groupedBy.value === 'currency')
+ useSecondary = !!groupedBySecondary.value.currency
+ else if (groupedBy.value === 'type')
+ useSecondary = !!groupedBySecondary.value.type
+
+ return buildWalletGroups(
+ selectedWalletsIds.value,
+ walletsStore.itemsComputed,
+ groupedBy.value,
+ useSecondary,
+ )
+ })
+
+ function toggleMap(groupPrimary: string, groupSecondary?: string) {
+ walletsToggledMap.value = applyToggle(
+ walletsToggledMap.value,
+ groupedBy.value,
+ groupPrimary,
+ groupSecondary,
+ )
+ }
+
+ const typeGroupsStatus = computed(() =>
+ computeToggleStatus(walletsToggledMap.value, groupedBy.value),
+ )
+
+ function toggleOpened() {
+ if (groupedBy.value === 'none' || !groupedWalletsWithIds.value)
+ return
+
+ walletsToggledMap.value = applyToggleAll(
+ walletsToggledMap.value,
+ groupedBy.value,
+ groupedWalletsWithIds.value as GroupedWallets,
+ !!groupedBySecondary.value[groupedBy.value],
+ typeGroupsStatus.value,
+ )
+ }
+
+ const groupTabs = computed(() => {
+ const items: {
+ id: WalletsGroupedBy
+ label: string
+ }[] = [{
+ id: 'none',
+ label: t('wallets.page.none'),
+ }, {
+ id: 'type',
+ label: t('wallets.page.type'),
+ }]
+
+ if (walletsStore.currenciesUsed.length > 1) {
+ items.push({
+ id: 'currency',
+ label: t('wallets.page.currencies'),
+ })
+ }
+
+ return items
+ })
+
+ return {
+ groupedBySecondary,
+ groupedWalletsWithIds,
+ groupTabs,
+ toggleMap,
+ toggleOpened,
+ typeGroupsStatus,
+ walletsToggledMap,
+ }
+}