Fix @typescript-eslint/no-dynamic-delete

Author: peachbits

eslint.config.mjs

@@ -541,7 +541,6 @@ export default [
     rules: {
       '@typescript-eslint/ban-ts-comment': 'warn',
       '@typescript-eslint/explicit-function-return-type': 'warn',
-      '@typescript-eslint/no-dynamic-delete': 'warn',
       '@typescript-eslint/strict-boolean-expressions': 'warn',
       '@typescript-eslint/use-unknown-in-catch-callback-variable': 'warn'
     }

src/app.ts

@@ -102,7 +102,7 @@ const asServerDetails = asObject({
 const ENABLE_PERF_LOGGING = false
 const PERF_LOGGING_ONLY = false
 
-const perfTimers: NumberMap = {}
+const perfTimers = new Map<string, number>()
 const perfCounters: NumberMap = {}
 const perfTotals: NumberMap = {}
 
@@ -166,9 +166,9 @@ if (ENABLE_PERF_LOGGING) {
       perfTotals[label] = 0
       perfCounters[label] = 0
     }
-    if (typeof perfTimers[label] === 'undefined') {
+    if (typeof perfTimers.get(label) === 'undefined') {
       // @ts-expect-error
-      perfTimers[label] = global.nativePerformanceNow()
+      perfTimers.set(label, global.nativePerformanceNow())
     } else {
       clog(`${d}: PTIMER Error: PTimer already started: ${label}`)
     }
@@ -177,15 +177,16 @@ if (ENABLE_PERF_LOGGING) {
   // @ts-expect-error
   global.pend = function (label: string) {
     const d = makeDate()
-    if (typeof perfTimers[label] === 'number') {
+    const timer = perfTimers.get(label)
+    if (typeof timer === 'number') {
       // @ts-expect-error
-      const elapsed = global.nativePerformanceNow() - perfTimers[label]
+      const elapsed = global.nativePerformanceNow() - timer
       perfTotals[label] += elapsed
       perfCounters[label]++
       clog(
         `${d}: PTIMER ${label}:${elapsed}ms total:${perfTotals[label]}ms count:${perfCounters[label]}`
       )
-      delete perfTimers[label]
+      perfTimers.delete(label)
     } else {
       clog(`${d}: PTIMER Error: PTimer not started: ${label}`)
     }

src/components/FioAddress/ConnectWallets.tsx

@@ -134,20 +134,20 @@ export const ConnectWallets = (props: FioConnectWalletsProps) => {
   ): void => {
     if (value) {
       if (disconnectWalletsMap[item.key] != null) {
-        delete disconnectWalletsMap[item.key]
+        const { [item.key]: _, ...rest } = disconnectWalletsMap
+        setDisconnectWalletsMap(rest)
       } else {
-        connectWalletsMap[item.key] = item
+        setConnectWalletsMap({ ...connectWalletsMap, [item.key]: item })
       }
     } else {
       if (connectWalletsMap[item.key] != null) {
-        delete connectWalletsMap[item.key]
+        const { [item.key]: _, ...rest } = connectWalletsMap
+        setConnectWalletsMap(rest)
       } else {
-        disconnectWalletsMap[item.key] = item
+        setDisconnectWalletsMap({ ...disconnectWalletsMap, [item.key]: item })
       }
     }
 
-    setConnectWalletsMap({ ...connectWalletsMap })
-    setDisconnectWalletsMap({ ...disconnectWalletsMap })
     flashListToggle = !flashListToggle
   }
 

src/components/services/AccountCallbackManager.tsx

@@ -103,7 +103,7 @@ export function AccountCallbackManager(props: Props) {
       wallet.on('newTransactions', transactions => {
         for (const tx of transactions) {
           const txid = tx.txid.toLowerCase()
-          const cacheEntries = stakeMetadataCache[txid]
+          const cacheEntries = stakeMetadataCache.get(txid)
           // Assign cached stake metadata
           if (cacheEntries != null) {
             cacheEntries.forEach(cacheEntry => {
@@ -114,7 +114,7 @@ export function AccountCallbackManager(props: Props) {
               })
             })
 
-            delete stakeMetadataCache[txid]
+            stakeMetadataCache.delete(txid)
           }
         }
 

src/controllers/edgeProvider/client/pendingList.ts

@@ -44,7 +44,7 @@ export function makePendingList(): PendingList {
   }
 
   // Slower object-based version:
-  const map: Record<string, PendingCall> = {}
+  let map: Record<string, PendingCall> = {}
   return {
     add(call) {
       const id = ++lastId
@@ -54,7 +54,8 @@ export function makePendingList(): PendingList {
     grab(id) {
       const call = map[String(id)]
       if (call == null) return dummyCall
-      delete map[String(id)]
+      const { [String(id)]: _, ...rest } = map
+      map = rest
       return call
     }
   }

src/hooks/useFilter.ts

@@ -8,27 +8,29 @@ export function useFilter<T>(
 ): [T[], (filter: string) => void] {
   const [filteredData, setFilteredData] = React.useState(allData)
   const [filteredDataCache, setFilteredDataCache] = React.useState<
-    Record<string, T[]>
-  >({ '': allData })
+    Map<string, T[]>
+  >(new Map([['', allData]]))
   const [fifoCache, setFifoCache] = React.useState([''])
 
   const setFilter = (filter: string) => {
     // If already existing in cache just return the existing sort
-    if (filteredDataCache[filter] != null) {
-      setFilteredData(filteredDataCache[filter])
+    const filteredDataCacheForFilter = filteredDataCache.get(filter)
+    if (filteredDataCacheForFilter != null) {
+      setFilteredData(filteredDataCacheForFilter)
     } else {
       // Create the new filtered Array
       const newFilteredData = allData.filter((item, index) =>
         filterData(filter, item, index)
       )
       // Updated the cache
-      filteredDataCache[filter] = newFilteredData
+      filteredDataCache.set(filter, newFilteredData)
       fifoCache.unshift(filter)
       // Check if over maximum cache size
       if (fifoCache.length >= CACHE_MAX_SIZE) {
         const cacheKey = fifoCache.pop()
-        // @ts-expect-error
-        delete filteredDataCache[cacheKey]
+        if (cacheKey != null) {
+          filteredDataCache.delete(cacheKey)
+        }
       }
       // Update state
       setFifoCache(fifoCache)

src/plugins/gui/amountQuotePlugin.ts

@@ -799,7 +799,7 @@ export const createPriorityArray = (
   const priorityArray: PriorityArray = []
   if (providerPriorityMap != null) {
     // Create a copy of the providerPriorityMap to avoid modifying the original
-    const priorityMapCopy = { ...providerPriorityMap }
+    const priorityMapCopy = new Map(Object.entries(providerPriorityMap))
 
     // Create a separate object for preferred providers
     const preferredProviders: Record<string, boolean> = {}
@@ -812,7 +812,7 @@ export const createPriorityArray = (
           preferredProviders[provider] = true
           // Remove from the regular priority map if it exists there, so they
           // are omitted from normal ordering logic
-          delete priorityMapCopy[provider]
+          priorityMapCopy.delete(provider)
         }
       }
     }
@@ -824,8 +824,11 @@ export const createPriorityArray = (
 
     // Process the remaining providers by priority
     const tempPriorityList: Array<{ pluginId: string; priority: number }> = []
-    for (const pluginId in priorityMapCopy) {
-      tempPriorityList.push({ pluginId, priority: priorityMapCopy[pluginId] })
+    for (const pluginId of priorityMapCopy.keys()) {
+      tempPriorityList.push({
+        pluginId,
+        priority: priorityMapCopy.get(pluginId) ?? 0
+      })
     }
     tempPriorityList.sort((a, b) => b.priority - a.priority)
     let currentPriority = Infinity

src/plugins/stake-plugins/metadataCache.ts

@@ -7,9 +7,7 @@ export interface MetadataCacheEntry {
   metadata: EdgeMetadata
 }
 
-export type MetadataCache = Record<string, MetadataCacheEntry[]>
-
-export const stakeMetadataCache: MetadataCache = {}
+export const stakeMetadataCache = new Map<string, MetadataCacheEntry[]>()
 
 export const cacheTxMetadata = (
   txid: string,
@@ -18,6 +16,10 @@ export const cacheTxMetadata = (
 ) => {
   // Add metadata cache entry:
   const key = txid.toLowerCase()
-  stakeMetadataCache[key] = stakeMetadataCache[key] ?? []
-  stakeMetadataCache[key].push({ currencyCode, metadata })
+  const cacheEntries = stakeMetadataCache.get(key)
+  if (cacheEntries == null) {
+    stakeMetadataCache.set(key, [{ currencyCode, metadata }])
+  } else {
+    cacheEntries.push({ currencyCode, metadata })
+  }
 }

src/util/FioAddressUtils.ts

@@ -419,7 +419,7 @@ export const updatePubAddressesForFioAddress = async (
   error?: Error | FioError | null
 }> => {
   if (!fioWallet) throw new Error(lstrings.fio_connect_wallets_err)
-  const connectedWalletsFromDisklet = await getConnectedWalletsForFioAddress(
+  let connectedWalletsFromDisklet = await getConnectedWalletsForFioAddress(
     fioWallet,
     fioAddress
   )
@@ -447,7 +447,8 @@ export const updatePubAddressesForFioAddress = async (
       if (pubAddressFromStore !== publicAddress) {
         publicAddress = pubAddressFromStore
       }
-      delete connectedWalletsFromDisklet[fullCurrencyCode]
+      const { [fullCurrencyCode]: _, ...rest } = connectedWalletsFromDisklet
+      connectedWalletsFromDisklet = rest
     }
     iteration.ccWalletArray.push({
       fullCurrencyCode,

src/util/exchangeRates.ts

@@ -45,13 +45,13 @@ export type RatesParams = ReturnType<typeof asRatesParams>
 type RateMap = Record<string, number | null>
 
 const rateMap: RateMap = {}
-const resolverMap: Record<
+const resolverMap = new Map<
   string,
   {
     resolvers: Function[]
     rateQueueEntry: RatesParams
   }
-> = {}
+>()
 let inQuery = false
 
 let numDoQuery = 0
@@ -62,7 +62,7 @@ const doQuery = async (doFetch?: EdgeFetchFunction): Promise<void> => {
   const groupedParams = new Map<string, RatesParams>()
 
   // Fill the query up to RATES_SERVER_MAX_QUERY_SIZE entries
-  const values = Object.values(resolverMap)
+  const values = resolverMap.values()
   for (const value of values) {
     const map = groupedParams.get(value.rateQueueEntry.targetFiat)
     if (map == null) {
@@ -92,9 +92,10 @@ const doQuery = async (doFetch?: EdgeFetchFunction): Promise<void> => {
         const cleanedRates = asRatesParams(json)
 
         // Since the requests are USD only, we'll match up the original requests to what we've received
-        for (const [key, { rateQueueEntry, resolvers }] of Object.entries(
-          resolverMap
-        )) {
+        for (const [
+          key,
+          { rateQueueEntry, resolvers }
+        ] of resolverMap.entries()) {
           // Match crypto/fiat requests
           if (rateQueueEntry.crypto.length === 1) {
             const cryptoToMatch = rateQueueEntry.crypto[0]
@@ -119,13 +120,13 @@ const doQuery = async (doFetch?: EdgeFetchFunction): Promise<void> => {
             if (crypto?.rate != null && fiat?.rate != null) {
               const rate = crypto.rate / fiat.rate
               rateMap[key] = rate
-              if (resolverMap[key] == null) {
+              if (resolverMap.get(key) == null) {
                 clog(`${n} oops`)
                 continue
               }
 
               clog(`${n} deleting ${key}`)
-              delete resolverMap[key]
+              resolverMap.delete(key)
               if (resolvers.length) {
                 resolvers.forEach((r, i) => {
                   r(rate)
@@ -155,13 +156,13 @@ const doQuery = async (doFetch?: EdgeFetchFunction): Promise<void> => {
             if (fromFiat?.rate != null && toFiat?.rate != null) {
               const rate = fromFiat.rate / toFiat.rate
               rateMap[key] = rate
-              if (resolverMap[key] == null) {
+              if (resolverMap.get(key) == null) {
                 clog(`${n} oops`)
                 continue
               }
 
               clog(`${n} deleting ${key}`)
-              delete resolverMap[key]
+              resolverMap.delete(key)
               if (resolvers.length) {
                 resolvers.forEach((r, i) => {
                   r(rate)
@@ -179,16 +180,17 @@ const doQuery = async (doFetch?: EdgeFetchFunction): Promise<void> => {
         console.warn(`Error querying rates server ${e.message}`)
       }
       // Resolve all the promises with value 0
-      Object.entries(resolverMap).forEach(entry => {
+      const resolversMapEntries = [...resolverMap.entries()]
+      resolversMapEntries.forEach(entry => {
         const [pairDate, value] = entry
         clog(`${n} throw deleting ${pairDate}`)
-        delete resolverMap[pairDate]
+        resolverMap.delete(pairDate)
         value.resolvers.forEach(resolve => resolve(0))
       })
     }
   }
 
-  if (Object.keys(resolverMap).length > 0) {
+  if (resolverMap.size > 0) {
     clog(`${n} Calling doQuery again`)
     await doQuery(doFetch)
   } else {
@@ -204,16 +206,17 @@ const addToQueue = (
   maxQuerySize: number,
   doFetch?: EdgeFetchFunction
 ) => {
-  if (resolverMap[rateKey] == null) {
+  const rateKeyResolver = resolverMap.get(rateKey)
+  if (rateKeyResolver == null) {
     // Create a new entry in the map for this pair/date
     clog(`adding ${rateKey}`)
-    resolverMap[rateKey] = {
+    resolverMap.set(rateKey, {
       resolvers: [resolve],
       rateQueueEntry: entry
-    }
+    })
   } else {
     // Add a resolver to existing pair/date entry
-    resolverMap[rateKey].resolvers.push(resolve)
+    rateKeyResolver.resolvers.push(resolve)
     return
   }
   if (!inQuery) {