Skip to content

Open source personal finance application

29.1 KB
Raw Blame

title: What Changed Since Firebase description: What changed between v6 (Firebase) and the current Supabase + PowerSync app - backend, performance, security, tests, and architecture. navigation: icon: i-lucide-hamburger seo: title: What Changed Since Firebase description: Side-by-side comparison of Finapp v6 (Firebase) and the current Supabase Postgres + PowerSync app - backend, performance, security, tests, and architecture.

Two eras. Finapp's backend went from Firebase (v6 - Firebase Realtime Database + Firebase Auth) to the current stack: Supabase Postgres + PowerSync (offline-first) + Supabase Auth.

This document is a side-by-side comparison of what changed. The app-level improvements (performance, refactoring, UX, TypeScript, i18n) and the backend, auth, sync, and dependency sections all describe the current codebase. See Architecture for a full description of the current Supabase + PowerSync architecture.

Side-by-side comparison of what the app looks like on the firebase branch (v6, Firebase) vs the current Supabase + PowerSync app.

Backend

firebase (Firebase) current
Database Firebase Realtime Database Supabase Postgres (replicated by PowerSync)
Auth Firebase Auth via nuxt-vuefire Supabase Auth (email/password)
Data access Real-time listeners (getDataAndWatch) Local SQLite via db.watch(...), writes via upsertRow / deleteRow
Validation Firebase security rules (JSON) Postgres RLS (auth.uid()) + client-side Zod schemas
Server code None (client-only SDK) Supabase migrations + self-hosted PowerSync sync rules (per-user WHERE "userId" = auth.user_id())
Exchange rates Client-side fetch rates table synced through PowerSync like any other table
User settings localStorage only user_settings table (baseCurrency, locale), auto-created on signup by a trigger
Schema indexes N/A Client SQLite indexes in AppSchema.ts (userDate: ['userId','date'], plus userId per table)
Migration N/A Firebase JSON export -> transform -> PostgREST import via scripts/import-firebase.mjs (see Migration History)
Account deletion N/A RLS-scoped delete of the user's rows + local wipe (removeAllUserData)

What the current backend gives

  • Offline-first - all reads/writes hit local SQLite; PowerSync syncs in the background, so the app works fully offline
  • Per-user isolation - Postgres RLS (auth.uid()) + PowerSync sync rules guarantee each user only ever syncs their own rows
  • Typed client schema - AppSchema.ts defines the SQLite tables; row<->item transforms are centralized in transforms.ts
  • Automatic upload queue - local mutations are queued and uploaded by the connector (uploadData), with auto-reconcile on rejected ops
  • Incremental sync - PowerSync streams only changed rows after the initial sync

Store Pattern

firebase current
Data source Firebase listener -> setTrns() db.watch('SELECT * FROM ...') -> reconcile -> setX()
Persist deepUnref() + immediate localforage.setItem() PowerSync SQLite is the source of truth; a blob read-through cache (useStoreCache.ts) primes the first frame
Offline ops Manual helpers in trns/helpers.ts, ad-hoc localStorage keys None needed - PowerSync's built-in upload queue handles offline writes
ID system Firebase push IDs Client-generated UUIDs, stable across sync (no remap)
Optimistic UI Partial (fire-and-forget) Full: upsertRow/deleteRow write local SQLite -> watch re-emits -> connector uploads in the background
Sync verification None PowerSync checksums per bucket; rejected uploads trigger auto-reconcile (uploadReconcile.ts)

The vue-deepunref dependency is removed. Store data uses shallowRef, so deep cloning on every persist was unnecessary.

Performance

Algorithm improvements

What firebase current Impact
Wallet totals getWalletTotal(id) called per wallet in reduce - each call filters all trns: O(W×N) getWalletsTotals() single pass, distributes amounts via Map: O(N), then O(1) lookup per wallet 5 wallets × 10K trns: ~50K → ~10K ops
Interval bucketing Inline in Item.vue: intervalsInRange.reduce() filtering all trns per interval: O(N×I) Extracted to bucketTrnsByIntervals(): single pass + binary search: O(N log I) Year/365 days/5K trns: 1.8M → ~43K comparisons
Transaction filtering 6 sequential .filter() chained via reduce + walletsIds.some(w => includes(w)) O(W²) + always sorts O(N log N) Single .filter() with early returns + Set.has() O(1) + sorting optional 5 intermediate arrays + O(W²) → single pass + O(1); sort O(N log N) skipped when not needed
Wallet lookup in getTotal walletsIds.includes(): O(W) per transfer new Set(walletsIds).has(): O(1) per transfer Linear → constant per lookup
Demo data generation { ...acc } spread in .reduce() + getTransactibleIds() called twice per iteration Direct acc[i] = ... + lookups cached before loop O(N²) → O(N)
Category statistics categoriesStat eagerly computes both grouped and ungrouped on every change; filter().at(0) for biggest Lazy computed() per variant, only accessed one executes; .find() stops at first match Up to 2× fewer computeCategoriesWithData calls
Vertical categories filter verticalCategories.filter(c => c.value !== 0) called twice in template (title + v-for): re-evaluated on every render Cached in visibleVerticalCategories computed: filtered once, reused 2 filter passes → 1 cached
Number formatting currency.js library + currencies.find() O(N) called twice per format Native Intl.NumberFormat cached in Map + currencyMap.get() O(1) No library overhead; formatter created once per precision
Last created trn Object.keys().sort().find() - sorts all trns O(N log N) then searches Single O(N) pass tracking running max date 10K trns: ~130K ops → ~10K ops
Category parent check categoriesForBeParent calls Object.values(trns).some() O(N) per root category: O(M×N) Pre-built usedCategoryIds Set via for...in O(N) + Set.has() O(1) per check; no intermediate arrays 200 categories × 10K trns: ~2M → ~10K ops
Recent categories Object.keys(trns).filter().sort() O(N log N) + acc.some(c => c.id) O(K²) dedup + includes() O(W) per category Single O(N) pass via Map tracking latest date + entries().toSorted() O(K log K) + Set.has() O(1) 10K trns: ~130K + K² → ~10K + K log K ops
Transactible categories .reduce() with acc.includes() O(M) + childIds.filter(!acc.includes) O(C×M): O(M²) Map<parentId, childIds[]> built in O(M) + Set dedup O(1) per check 200 categories: ~40K → ~200 ops
Transfer detection transferCategoriesIds.includes(categoryId) O(W) array scan per transaction trn.type === TrnType.Transfer O(1) enum comparison Linear → constant per check
Type filter counts 3 separate .filter() passes over trnsIds (expense, income, transfer): O(3N) Single loop with counters object: O(N) 3 full passes → 1 pass
Trn item cache in list computeTrnItem(id) called twice per item in template (item + date): O(2P) calls Pre-computed trnItemsMap via Map: O(P) compute + O(1) lookups 30 items: ~60 → ~30 computations per render
Group totals cache getTotalOfTrnsIds() called twice per group in template (income + expense): O(2G) calls Pre-computed groupTotals Map + paginatedTotal computed: O(G) compute + O(1) lookups 15 groups: ~30 → ~15 total computations per render
Category grouping sort categories.sort() called inside reduce on every child push: O(K² log K) per parent Sort once after grouping loop, only if length > 1: O(K log K) per parent 5 children: ~50 → ~12 comparisons
Category grouping totals getTotalOfTrnsIds(cat.trnsIds).sum called twice per child (for push value + parent sum) Computed once into catTotal, reused: single call per child 2× fewer getTotal calls per child category
Data sync Firebase full replacement on every update: O(N) Delta sync: only changed records fetched - O(D) where D « N Avoids reprocessing unchanged transactions
Interval generation list.unshift(current) in while loop: O(n) per call, O(n²) total list.push(current) + list.reverse(): O(1) per call, O(n) total Year/365 days: ~66K shifts → ~365 pushes + 1 reverse
Date duration keys Dynamic { [\${period}s`]: value } - TS seesRecord<string, number>, no type check against Duration` toDuration(period, value) returns typed Duration via exhaustive switch Compile-time safety; new period variants cause errors, not silent fallback
Date formatting Each format function called twice (type: 'start' + type: 'end'), concatenated; 3 IIFE switch blocks for period comparison Each format function returns full string; isSamePeriod(a, b, period) replaces all 3 switches ~40% fewer lines in useGetDateRange; no double calls
Average computation sum !== 0 checked 3 times + Object.keys(items).length > 0 guard Early sum === 0 exit; day average always present (range ≥ 2 guaranteed) Single check instead of 4
Favorite categories sort Inline sort duplicating parent-name + name logic (8 lines) Reuses compareCategoriesByParentAndName utility (1 line) DRY; single sort implementation to maintain
Recent categories loop .reduce() iterates all sorted entries even after reaching maxCategories limit for loop with break stops at limit 200 categories, limit 16: ~200 → ~16 iterations
Recent categories iteration for...of Object.keys(trnsItems) creates intermediate array for...in trnsItems iterates directly on object No intermediate array allocation for 10K+ trns
Category IDs reuse Object.keys(items.value) called separately in categoriesRootIds, favoriteCategoriesIds Both reuse categoriesIds computed Keys computed once, shared across dependents
Transactible IDs reuse categoriesIdsForTrnValues re-filters all categories with !hasChildren check Delegates to already-computed transactibleIds + .filter(id !== 'transfer') Avoids redundant O(M) parent scan
Children IDs dedup getChildrenIdsOrParent duplicates .filter() logic from getChildrenIds Delegates to getChildrenIds(), checks .length Single filter implementation

Bundle and rendering

What firebase current
ECharts 9 components in main bundle (incl. PieChart, DataZoom, MarkPoint) 7 components in lazy-loaded async chunk (unused removed)
Theme plugin 81 lines with SSR inline scripts and regex replacements 32 lines, SPA-only appConfig updates from localStorage
Persist deepUnref() on every localforage.setItem() - full recursive clone Direct write, debounced 300ms, no cloning
Responsive layout useWindowSize() JS listener for sidebar Pure CSS sm: / md: Tailwind breakpoints
Container queries Media queries only CSS container queries (@xl/page:, @md/page:) for layout-aware sizing
Dependencies currency.js for number formatting Native Intl.NumberFormat (no dependency)
Fonts 4 families (Roboto, Roboto Condensed, Nunito, Unica One), multiple weights, cyrillic only - Google Fonts <link> in head Same 4 families via @nuxt/fonts, cyrillic + latin
Dark mode import colors from 'tailwindcss/colors' + as any cast usePreferredDark() + hardcoded neutral, handles system mode

Security

What firebase current
Calculator parser new Function(expression) - code injection risk, requires unsafe-eval CSP Recursive descent parser - only +,-,*,/ on numeric literals
Input validation Firebase rules (client can't verify) Client-side Zod schemas + Postgres column types / RLS
Auth tokens Firebase-managed Supabase-managed JWT + refresh token (validated by PowerSync via JWKS)
Session lifetime Firebase default Supabase Auth session with automatic token refresh
Cascade deletes N/A (Firebase) RLS-scoped delete of the user's rows (no FK constraints; PowerSync clears local data)
Data integrity None enforced in code Transfer ↔ categoryId='transfer', type change normalization, name uniqueness
Redirect safety No validation getSafeRedirectPath() - only relative paths starting with / (not //)

Auth

firebase current
Provider Firebase Auth Supabase Auth (email/password)
Plugin nuxt-vuefire (auto-handles auth) plugins/powersync.client.ts - connects PowerSync when a session resolves
Token flow Firebase SDK internal SupabaseConnector.fetchCredentials() hands the Supabase JWT to PowerSync; validated via JWKS
Offline Firebase SDK handles reconnect Persisted Supabase session in localStorage; the route guard reads it synchronously (useAuthSession)
Auth state hint None Persisted session read synchronously at cold start (getPersistedSession()), no network
Callback Firebase redirect Email/password sign-in, no OAuth popups
CORS N/A Supabase + PowerSync service URLs from runtime config
Login Firebase auto-redirect Stores the intended redirect, signs in via useSupabaseAuth()

Sync and offline

firebase current
Mechanism Ad-hoc helpers in trns/helpers.ts PowerSync's built-in upload queue - no hand-written offline queue
Writes Scattered localStorage keys upsertRow / deleteRow write local SQLite (INSERT/UPDATE, never ON CONFLICT)
Upload saveTrnToAddLaterLocal(), removeTrnToDeleteLaterLocal() SupabaseConnector.uploadData() drains the queue to Supabase
Reads Manual on next load db.watch(...) - one subscription covers initial load + realtime, local + synced
Conflict handling None Auto-reconcile: rejected uploads compute divergedOps (uploadReconcile.ts) and trigger forceResync
Validation None Client-side Zod schemas on form input; Postgres RLS on the server
First frame None Blob read-through cache (useStoreCache.ts) primes stores before PowerSync init

PWA

firebase current
Strategy injectManifest (custom service worker via SW env var) generateSW (auto-generated by Workbox)
Service worker Hand-written sw.ts None - Workbox generates it
Precaching Manual configuration Automatic for all build assets
Icons Fetched from Iconify API at runtime Bundled at build time via clientBundle

TypeScript

firebase current
Strict mode Enabled, but unresolved errors Zero TypeScript errors
Type casts as any used across codebase Zero as any - replaced with type guards, @vue-ignore, narrow casts
Transfer detection transferCategoriesIds computed array TrnType.Transfer enum + discriminated union types
Runtime validation None Zod schemas for user settings, rates, stat config, date params
Date period functions getStartOf(date, string), getEndOf(date, string) - default fallback to day Typed as Period, exhaustive switch with case 'day' - new variants cause compile errors
Duration construction Dynamic { [\${period}s`]: value }- TS seesRecord<string, number>` toDuration(period, value): Duration - typed return via exhaustive switch
Stat type mapping Record<string, TrnType[]> with ?? fallback Record<SeriesSlugSelected | StatTabSlug, TrnType[]> - all keys covered, no fallback needed
Average key resolution key as keyof TotalReturns unsafe cast + as number Typed key: keyof TotalReturns via explicit 'netIncome' -> 'sum' mapping, no casts
Currency rate fallback rates[code] || 1, wallet?.currency || 'USD' - falsy 0/'' triggers fallback rates[code] ?? 1, wallet?.currency ?? 'USD' - only null/undefined triggers fallback
Query param parsing if (data.rangeOffset) - falsy 0 skipped if (data.x !== undefined) - zero values applied correctly
Total props baseCurrencyCode?: string loose type baseCurrencyCode?: CurrencyCode - consistent with getAmountInRate
Category stat params trnsItems: Record<TrnId, { categoryId?: string }> inline type trnsItems: Record<TrnId, Pick<TrnItem, 'categoryId'>> - linked to source type
Sort null guard sortCategoriesByAmount checks if (!a || !b) at runtime Guard removed - TS already guarantees CategoryWithData parameters; explicit : number return type

Tests

firebase current
Config No vitest config 2 vitest projects: unit (node), store (happy-dom)
Sync tests None Row<->item transforms, upload reconcile / divergence planning (uploadReconcile.test.ts)
Calculator tests Basic 46 cases (precedence, decimals, division by zero, injection safety)
Extracted logic tests None Wallet filter/grouping/counts (archived exclusion, available visibility), category grouping, auth gate, stat barUtils, useStatItem
Test infrastructure None setup-store.ts (shared mocks for PowerSync/Supabase)

Refactoring

Pure function extraction

Business logic moved from Vue components into testable pure functions:

  • Statistics: bucketTrnsByIntervals, computeAverageTotal, sortCategoriesByAmount, getSelectedType, computeBarStyle, formatCompactAmount, computeSeriesAverage, getTrnTypeByAmount
  • Wallets: filterWalletsByCurrency, filterWalletsByViewType, groupWalletsByProperty, computeWalletCounts, sumWalletAmounts, getCreditAvailable
  • Categories: collectCategoriesByTrns, flattenCategoriesWithValues, groupCategoriesWithValues
  • Sync: reconcile (store reconciliation against fresh watch emissions), planDivergence (upload reconcile), transforms (row<->item)
  • Demo: simplified to read-only - removed per-entity CRUD methods (addDemoCategory, deleteDemoWallet, etc.), only generateDemoData() + isDemo

Component changes

Added: ActionButton, ChipButton, TabsScroll, TextMuted, SettingsCard, TitleSection, ItemBody, BottomSheetModal, WalletsPageListItem, WalletsPageGroupHeader, Onboarding, CurrenciesPageList, CurrenciesItem, ConfigSwitch, GroupingToggle, SelectorItem

Removed: Item1–4, Tabs2, TabsItem1/3/4, TextSm1/2, Title3/6/7/8, TitleOption, ToggleAction, SwitcherTabs, Welcome, Round (stat chart), SectionWithCollapse, CurrenciesToggleDep, getStyles.ts

Component patterns

  • Class merging: getStyles() utility removed - replaced with cn() (clsx + tailwind-merge)
  • Form inputs: value/updateValue props -> v-model / defineModel

Composable decomposition

  • Wallets: useWalletContextMenu, useWalletDelete, useWalletsFilter, useWalletsGrouping, useWalletsCounts
  • Categories: useCategoryContextMenu
  • Statistics: Symbol-based injection keys (filterKey, statDateKey, statConfigKey) for type-safe provide/inject
  • Stat pages: useStatPage composable - extracts duplicated stat infrastructure (filter, statConfig, statDate creation + provide, activeTab, storageKey, trnsIds, maxRange) from three page components (Dashboard, Category, Wallet) into a single reusable composable. Each page passes only its entity-specific filter logic via getTrnsFilter callback. Script section reduced by 24–53% across the three pages
  • useCategoryLongPress composable: extracted 59 lines of duplicated long-press logic from Round2lines.vue, Line.vue, and Vertical.vue into a shared composable. Handles long-press to create transactions from categories with proper date selection from chart intervals
  • useStatDate encapsulation: navigation computed properties (shouldShowNav, isAtEnd, isAtStart, isDayToday, shouldShowNavHome) and direct params.value mutations moved from Navigation.vue and chart/Wrap.vue into useStatDate methods (selectInterval(), resetInterval(), setIntervalsBy(), navigate()). Navigation.vue reduced from ~54 lines of script to 5 lines
  • Duplicate stat/date/Nav.vue removed: identical copy of date/Nav.vue was deleted - only the canonical DateNav component remains
  • UiNumberStepper component: extracted duplicated ±/input counter pattern from ConfigModal.vue into a reusable UI primitive with v-model, min, max props
  • Stat component self-containment: StatAverage consolidated three conditional Amount blocks into one via computed props; StatSumWrap and StatChartWrap removed redundant prop-drilling in favor of inject; StatItem merged two modal blocks into one via state-machine pattern
  • Config caching: Section2.vue and Line.vue cache statConfig.config.value.catsList.* reads into computed properties (isItemsBg, isLines, isRoundIcon, isListGrouped, etc.) for template readability
  • Range.vue simplified: replaced manual intervalsInRange indexing with statDate.selectedInterval; extracted isIntervalSelected computed
  • useStatItem cleanup: extracted baseTrnsIdsForSelection computed to eliminate duplicated interval-selection logic; fixed unsafe type.value as keyof TotalReturns cast with type.value ?? 'sum' fallback; fixed chart average denominator using wrong data source (intervalsData -> intervalsDataWithFilteredCategories)
  • useCategoriesExpanded composable: extracted 52-line expand/collapse logic from DetailedSection.vue (286->234 lines)
  • Stat component rename: Section/Section2 -> RoundSection/DetailedSection for clarity
  • barUtils extraction: computeBarStyle() and formatCompactAmount() extracted from inline template logic into testable utilities
  • Wallet statistics consistency: archived wallets fully excluded from all counts (total, type sums, withdrawal, available) via early continue; available.isShow requires both withdrawal and credit wallets; auto-reset filter to Total when currency switch produces empty results
  • Store sync consolidation: showErrorToast/showSuccessToast/showWarningToast merged into generic showToast(type, key, params?)
  • Wallet constants: WALLET_STORAGE_KEYS extracted from inline strings to constants.ts

Semantic renaming

firebase current
getTrnsIds filterTrnsIds
getCategoriesWithData computeCategoriesWithData
getTotalOfTrnsIds computeTotalForTrnsIds
getChildsIds getChildrenIds
trnFormCreate / Edit / Duplicate openFormForCreate / Edit / Duplicate
getIsShowSum shouldShowSum
isItTransactible isTransactible
editedAt updatedAt
TransferType TransferSide
Selector2 (categories) SelectorGrid
Selector (categories) SelectorTree
Checkbox (ui) SwitchItem
Tabs1 (ui) TabsBar
Toggle3 (ui) ToggleControlled
Section (stat) RoundSection
Section2 (stat) DetailedSection
isNotTransferCategory shouldShowAmounts
biggestCatNumber maxCategoryValues
addMarkArea withMarkArea
toggleOpened toggleAllCategoriesExpanded

Data model

firebase current
Category children Denormalized childIds array Computed dynamically from parentId
Transfer detection transferCategoriesIds (computed from category data) TrnType.Transfer enum value
Adjustment Not distinguished categoryId === 'adjustment', excluded from income/expense stats

UX Improvements

  • Haptic feedback on transaction submit (mobile vibration)
  • Accessibility: <div> -> <button> in interactive components, i18n aria-label on icon-only buttons
  • Calculator: fixed infinite loop on zero result, proper 0. decimal display, rounded division results
  • Form: amount clears immediately after submit, popover closes before edit navigation
  • Onboarding: Welcome component replaced with Onboarding - improved layout, cookie-persisted state (finapp.isOnboarded)
  • Currencies page: two sections (Used / All) with global search, O(1) lookup via currencyMap
  • Wallet/category detail: edit/delete actions moved to three-dot menu
  • Wallet statistics: archived wallets fully excluded from all filter tabs; Available tab only shown when both withdrawal and credit wallets exist; filter auto-resets to Total on currency switch if current filter is empty
  • Wallet edit guard: redirect to /wallets when wallet doesn't exist
  • Toast dismiss: click anywhere on toast notification to close it
  • Layout: keepalive prop from layout slot for page transition persistence
  • Settings page: reorganized with SettingsCard, language dropdown, currency picker modal, danger zone with "Delete all data"
  • Login page: version display at bottom

i18n

firebase current
Error messages Generic or none Per-entity error keys (categories.errors.*, wallets.errors.*, trns.errors.*)
Form labels Verbose (Category name, Category color) Concise (Name, Color, Icon)
Onboarding welcome.* keys onboarding.* with step-by-step guidance
Theme neutral, radius Background color, Rounding, Appearance
Typos errorChilds errorChildren

Code Quality

Removed from firebase

  • vue-deepunref dependency
  • Old page-specific wallet composables
  • Dead code: unused props, emits, functions, stale TODOs
  • Deprecated types: WalletsDirty, TrnItemDirty, TransferDeprecated, TrnTypeSlug
  • CSS utilities: flex-center-col, absolute-center, layoutBase
  • nuxt-vuefire and firebase dependencies
  • Firebase config files (firebase.json, .firebaserc, pnpm-workspace.yaml)

Fixed

  • Memory leaks: addEventListener without cleanup, ResizeObserver without disconnect
  • Null spreading in 3 stores (missing ?? {} guards)
  • Emit during render in SelectionCategoriesFast
  • Magic numbers replaced with TrnType enum (8 places)
  • ref<any> replaced with proper types (4 files)
  • Error layout localized (hardcoded English -> i18n keys)
  • Tailwind v4 CSS syntax: [var(--name)] -> (--name) functional notation
  • Radius uses ?? (not ||) so 0 is valid: radius ?? 0.375
  • CSS utility typo: bottomSheetDrugClassesCustom -> bottomSheetDragClassesCustom
  • ESLint: layout vue/no-multiple-template-root exception
  • createLogger(prefix) - dev-only log, always-on warn and error, with [prefix] formatting across all modules
  • Hardcoded 'ru' locale in chart formatters -> dynamic locale from settings
  • Statistics.vue empty group sections hidden with v-show
  • Selector.vue onSelectRange(value: any) -> typed { end: unknown, start: unknown }
  • setWalletViewType type fixed from WalletType | 'total' to WalletViewTypes | 'total'
  • Version bumped from v6.6.4 (the firebase branch baseline)
  • useAmount.getAmountInBaseRate: dead noFormat param removed, unnecessary + unary on number removed
  • useFilter: redundant [...array.filter()] and [...string.split()] spreads removed - both methods already return new arrays
  • getUCalendarTimedDate: new Date(string) parsed as UTC -> date.toDate(getLocalTimeZone()) for correct local timezone
  • useGetDateRange: type: 'start' | 'end' pattern removed - format functions return full strings directly, 3 IIFE switches replaced with isSamePeriod helper
  • getIntervalsInRange: rangeOffset made optional in IntervalsInRangeProps - not used by getIntervalsInRange, only by calculateIntervalInRange
  • compareCategoriesByParentAndName: || -> ?? for empty string fallback (consistent nullish semantics)
  • useCategoriesStore: removed 5 unnecessary ?? {} defensive checks - items is always initialized via shallowRef
  • useCategoryLongPress: removed redundant ! after optional chaining (value?.start already narrowed)
  • useCategoriesExpanded: forEach -> for...of; reduce with as cast -> Object.fromEntries
  • sortCategoriesByAmount: renamed isP/isN -> bothPositive/bothNegative for readability; removed redundant categories ??= [] (already initialized in grouping)

Dependencies

(What changed from the firebase branch to the current app. For the full list see the project package.json.)

Removed (firebase era) Added (current)
firebase @powersync/web
nuxt-vuefire @supabase/supabase-js
vue-deepunref @vueuse/nuxt
currency.js zod
es-toolkit