remove StorageErrorClassValue type

Author: sosek108

lib/OnyxUtils.ts

@@ -891,13 +891,13 @@ function retryOperation<TMethod extends RetriableOnyxOperation>(
     Logger.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying. Error: ${error}`);
     reportStorageQuota(error);
 
-    // @ts-expect-error No overload matches this call.
     return remove(keyForRemoval).then(() => {
         // Mark the eviction only once the deletion has actually completed, immediately before the
         // retry it pairs with. Recording earlier lets a concurrent write's capacity failure consume
         // the marker as a no-progress cycle while this deletion is still pending and may yet free
         // space — so the verdict belongs to the retry that follows the deletion, not the eviction call.
         StorageCircuitBreaker.recordEviction();
+        // @ts-expect-error No overload matches this call.
         return onyxMethod(defaultParams, nextRetryAttempt);
     });
 }

lib/storage/errors.ts

@@ -1,5 +1,3 @@
-import type {ValueOf} from 'type-fest';
-
 /**
  * Shared vocabulary for storage write failures. The *classes* are engine-agnostic; the *matching*
  * is not — each storage provider knows its own error dialect and owns its classifier (see each
@@ -26,8 +24,6 @@ const StorageErrorClass = {
     UNKNOWN: 'unknown',
 } as const;
 
-type StorageErrorClassValue = ValueOf<typeof StorageErrorClass>;
-
 /**
  * Normalizes any thrown value into a lowercased `{name, message}` pair for matching. Shared by every
  * provider's classifier so they all extract the error the same way.
@@ -40,4 +36,3 @@ function getErrorParts(error: unknown): {name: string; message: string} {
 }
 
 export {StorageErrorClass, getErrorParts};
-export type {StorageErrorClassValue};

lib/storage/providers/IDBKeyValProvider/classifyError.ts

@@ -1,12 +1,12 @@
+import type {ValueOf} from 'type-fest';
 import {StorageErrorClass, getErrorParts} from '../../errors';
-import type {StorageErrorClassValue} from '../../errors';
 
 /**
  * Classifies an IndexedDB write failure into the shared storage taxonomy (lib/storage/errors.ts).
  * Matching is done on the lowercased error name and message. This is the IndexedDB engine's own
  * dialect — it is NOT shared with other engines.
  */
-function classifyIDBError(error: unknown): StorageErrorClassValue {
+function classifyIDBError(error: unknown): ValueOf<typeof StorageErrorClass> {
     const {name, message} = getErrorParts(error);
 
     // Non-serializable data passed to IDBObjectStore.put — retrying is futile.

lib/storage/providers/classifySQLiteError.ts

@@ -1,5 +1,5 @@
+import type {ValueOf} from 'type-fest';
 import {StorageErrorClass, getErrorParts} from '../errors';
-import type {StorageErrorClassValue} from '../errors';
 
 /**
  * Classifies a SQLite write failure into the shared storage taxonomy (lib/storage/errors.ts).
@@ -10,7 +10,7 @@ import type {StorageErrorClassValue} from '../errors';
  * SQLite surfaces fewer distinct write-failure shapes than IndexedDB. As telemetry from the UNKNOWN
  * bucket (see OnyxUtils.retryOperation) reveals recurring native errors, add matchers here.
  */
-function classifySQLiteError(error: unknown): StorageErrorClassValue {
+function classifySQLiteError(error: unknown): ValueOf<typeof StorageErrorClass> {
     const {message} = getErrorParts(error);
 
     // Device disk full.

lib/storage/providers/types.ts

@@ -1,6 +1,7 @@
+import type {ValueOf} from 'type-fest';
 import type {OnyxKey, OnyxValue} from '../../types';
 import type {FastMergeReplaceNullPatch} from '../../utils';
-import type {StorageErrorClassValue} from '../errors';
+import type {StorageErrorClass} from '../errors';
 
 type StorageKeyValuePair = [key: OnyxKey, value: OnyxValue<OnyxKey>, replaceNullPatches?: FastMergeReplaceNullPatch[]];
 type StorageKeyList = OnyxKey[];
@@ -89,11 +90,11 @@ type StorageProvider<TStore> = {
     getDatabaseSize: () => Promise<DatabaseSize>;
 
     /**
-     * Classifies a write error from THIS engine into the shared {@link StorageErrorClassValue} taxonomy.
+     * Classifies a write error from THIS engine into the shared {@link StorageErrorClass} taxonomy.
      * Each provider owns its own matchers (IndexedDB DOMExceptions, SQLite messages, …) so the central
      * taxonomy stays engine-agnostic. Anything the provider doesn't recognize must return UNKNOWN.
      */
-    classifyError: (error: unknown) => StorageErrorClassValue;
+    classifyError: (error: unknown) => ValueOf<typeof StorageErrorClass>;
 
     /**
      * @param onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync