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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.vueindex 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.tsnew file mode 100644index 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,+ }+}