Library store refactor (#76)

* start of music store refactor

moving stuff into a state cache
better separate it from view logic

* added paginated list/album list

* reworked fetchAlbumList to remove ui state

refactored home screen to use new method
i broke playing songs somehow, JS thread goes into a loop

* don't reset parts manually, do it all at once

* fixed perf issue related to too many rerenders

rerenders were caused by strict equality check on object/array picks
switched artistInfo to new store
updated zustand and fixed deprecation warnings

* update typescript

and use workspace tsc version for vscode

* remove old artistInfo

* switched to new playlist w/songs

removed more unused stuff

* remove unused + (slightly) rework search

* refactor star

* use only original/large imges for covers/artist

fix view artist from context menu
add loading indicators to song list and artist views (show info we have right away)

* set starred/unstar assuming it works

and correct state on error

* reorg, remove old music slice files

* added back fix for song cover art

* sort artists by localCompare name

* update licenses

* fix now playing background grey bar

* update react-native-gesture-handler

for node-fetch security alert

* fix another gradient height grey bar issue

* update licenses again

* remove thumbnail cache

* rename to remove "Library" from methods

* Revert "remove thumbnail cache"

This reverts commit e0db4931f1.

* use ids for lists, pull state later

* Revert "use only original/large imges for covers/artist"

This reverts commit c9aea9065c.

* deep equal ListItem props for now

this needs a bigger refactor

* use immer as middleware

* refactor api client to use string method

hoping to use this for requestKey/deduping next

* use thumbnails in list items

* Revert "refactor api client to use string method"

This reverts commit 234326135b.

* rename/cleanup

* store servers by id

* get rid of settings selectors

* renames for clarity

remove unused estimateContentLength setting

* remove trackplayer selectors

* fix migration for library filter settings

* fixed shuffle order reporting wrong track/queue

* removed the other selectors

* don't actually need es6/react for our state

* fix slow artist sort on star

localeCompare is too slow for large lists

app/state/store.ts

@@ -1,19 +1,20 @@
-import { createMusicSlice, MusicSlice } from '@app/state/music'
 import { createSettingsSlice, SettingsSlice } from '@app/state/settings'
 import AsyncStorage from '@react-native-async-storage/async-storage'
-import create from 'zustand'
-import { persist, StateStorage } from 'zustand/middleware'
+import equal from 'fast-deep-equal'
+import create, { GetState, Mutate, SetState, State, StateCreator, StateSelector, StoreApi } from 'zustand'
+import { persist, subscribeWithSelector } from 'zustand/middleware'
 import { CacheSlice, createCacheSlice } from './cache'
+import { createLibrarySlice, LibrarySlice } from './library'
 import migrations from './migrations'
-import { createMusicMapSlice, MusicMapSlice } from './musicmap'
 import { createTrackPlayerSlice, TrackPlayerSlice } from './trackplayer'
 import { createTrackPlayerMapSlice, TrackPlayerMapSlice } from './trackplayermap'
+import produce, { Draft } from 'immer'
+import { WritableDraft } from 'immer/dist/internal'
 
 const DB_VERSION = migrations.length
 
 export type Store = SettingsSlice &
-  MusicSlice &
-  MusicMapSlice &
+  LibrarySlice &
   TrackPlayerSlice &
   TrackPlayerMapSlice &
   CacheSlice & {
@@ -21,59 +22,83 @@ export type Store = SettingsSlice &
     setHydrated: (hydrated: boolean) => void
   }
 
-const storage: StateStorage = {
-  getItem: async name => {
-    try {
-      return await AsyncStorage.getItem(name)
-    } catch (err) {
-      console.error(`getItem error (key: ${name})`, err)
-      return null
-    }
-  },
-  setItem: async (name, item) => {
-    try {
-      await AsyncStorage.setItem(name, item)
-    } catch (err) {
-      console.error(`setItem error (key: ${name})`, err)
-    }
-  },
-}
-
-export const useStore = create<Store>(
-  persist(
-    (set, get) => ({
-      ...createSettingsSlice(set, get),
-      ...createMusicSlice(set, get),
-      ...createMusicMapSlice(set, get),
-      ...createTrackPlayerSlice(set, get),
-      ...createTrackPlayerMapSlice(set, get),
-      ...createCacheSlice(set, get),
-
-      hydrated: false,
-      setHydrated: hydrated => set({ hydrated }),
-    }),
-    {
-      name: '@appStore',
-      version: DB_VERSION,
-      getStorage: () => storage,
-      whitelist: ['settings', 'cacheFiles'],
-      onRehydrateStorage: _preState => {
-        return async (postState, _error) => {
-          await postState?.setActiveServer(postState.settings.activeServer, true)
-          postState?.setHydrated(true)
-        }
+// taken from zustand test examples:
+// https://github.com/pmndrs/zustand/blob/v3.7.1/tests/middlewareTypes.test.tsx#L20
+const immer =
+  <
+    T extends State,
+    CustomSetState extends SetState<T>,
+    CustomGetState extends GetState<T>,
+    CustomStoreApi extends StoreApi<T>,
+  >(
+    config: StateCreator<
+      T,
+      (partial: ((draft: Draft<T>) => void) | T, replace?: boolean) => void,
+      CustomGetState,
+      CustomStoreApi
+    >,
+  ): StateCreator<T, CustomSetState, CustomGetState, CustomStoreApi> =>
+  (set, get, api) =>
+    config(
+      (partial, replace) => {
+        const nextState = typeof partial === 'function' ? produce(partial as (state: Draft<T>) => T) : (partial as T)
+        return set(nextState, replace)
       },
-      migrate: (persistedState, version) => {
-        if (version > DB_VERSION) {
-          throw new Error('cannot migrate db on a downgrade, delete all data first')
-        }
+      get,
+      api,
+    )
 
-        for (let i = version; i < DB_VERSION; i++) {
-          persistedState = migrations[i](persistedState)
-        }
+export type SetStore = (partial: Store | ((draft: WritableDraft<Store>) => void), replace?: boolean | undefined) => void
+export type GetStore = GetState<Store>
 
-        return persistedState
+// types taken from zustand test examples:
+// https://github.com/pmndrs/zustand/blob/v3.7.1/tests/middlewareTypes.test.tsx#L584
+export const useStore = create<
+  Store,
+  SetState<Store>,
+  GetState<Store>,
+  Mutate<StoreApi<Store>, [['zustand/subscribeWithSelector', never], ['zustand/persist', Partial<Store>]]>
+>(
+  subscribeWithSelector(
+    persist(
+      immer((set, get) => ({
+        ...createSettingsSlice(set, get),
+        ...createLibrarySlice(set, get),
+        ...createTrackPlayerSlice(set, get),
+        ...createTrackPlayerMapSlice(set, get),
+        ...createCacheSlice(set, get),
+
+        hydrated: false,
+        setHydrated: hydrated =>
+          set(state => {
+            state.hydrated = hydrated
+          }),
+      })),
+      {
+        name: '@appStore',
+        version: DB_VERSION,
+        getStorage: () => AsyncStorage,
+        partialize: state => ({ settings: state.settings, cacheFiles: state.cacheFiles }),
+        onRehydrateStorage: _preState => {
+          return async (postState, _error) => {
+            await postState?.setActiveServer(postState.settings.activeServerId, true)
+            postState?.setHydrated(true)
+          }
+        },
+        migrate: (persistedState, version) => {
+          if (version > DB_VERSION) {
+            throw new Error('cannot migrate db on a downgrade, delete all data first')
+          }
+
+          for (let i = version; i < DB_VERSION; i++) {
+            persistedState = migrations[i](persistedState)
+          }
+
+          return persistedState
+        },
       },
-    },
+    ),
   ),
 )
+
+export const useStoreDeep = <U>(stateSelector: StateSelector<Store, U>) => useStore(stateSelector, equal)