@gentleduck/upload 0.2.2 → 0.2.5

package/src/core/persistence/persistence.ts

@@ -22,7 +22,12 @@ export function serializeSnapshot<
     if (!hasIntent(item)) continue
 
     // Do not persist terminal items. Persistence is for resuming and recovery, not history.
-    if ((item.phase as string) === 'completed' || (item.phase as string) === 'canceled' || (item.phase as string) === 'error') continue
+    if (
+      (item.phase as string) === 'completed' ||
+      (item.phase as string) === 'canceled' ||
+      (item.phase as string) === 'error'
+    )
+      continue
 
     const cursor = hasCursor(item) ? item.cursor : undefined
 

package/src/core/utils/emitter/index.ts

@@ -1,4 +1,5 @@
 import type { TypedEmitter } from './emitter.types'
+
 export type { TypedEmitter } from './emitter.types'
 
 /**
@@ -29,7 +30,11 @@ export function createTypedEmitter<E extends Record<string, unknown>>(): TypedEm
   return {
     on<K extends keyof E & string>(type: K, cb: (payload: E[K]) => void): () => void {
       // Create listener set for this event type if it doesn't exist
-      const set = listeners[type] ?? (listeners[type] = new Set<(payload: E[K]) => void>())
+      let set = listeners[type]
+      if (!set) {
+        set = new Set<(payload: E[K]) => void>()
+        listeners[type] = set
+      }
       set.add(cb)
 
       // Return unsubscribe function

package/src/react/upload-provider.tsx

@@ -52,6 +52,31 @@ export function UploadProvider<
   return <UploadContext.Provider value={store}>{children}</UploadContext.Provider>
 }
 
+/**
+ * Hook to access the upload store from React context when present.
+ *
+ * Some higher-level hooks support either an explicit store argument or context.
+ * They use this helper so the context read stays unconditional without throwing
+ * when a caller intentionally passes a store instance.
+ */
+export function useOptionalUploadStore<
+  M extends IntentMap,
+  C extends CursorMap<M>,
+  P extends string,
+  R extends UploadResultBase = UploadResultBase,
+>(): UploadStore<M, C, P, R> | null {
+  const store = useContext(UploadContext)
+  if (store === null) {
+    return null
+  }
+
+  if (!isUploadStore<M, C, P, R>(store)) {
+    throw new Error('UploadProvider received an invalid store value')
+  }
+
+  return store
+}
+
 /**
  * Hook to access the upload store from React context.
  *
@@ -74,8 +99,8 @@ export function useUploadStore<
   P extends string,
   R extends UploadResultBase = UploadResultBase,
 >(): UploadStore<M, C, P, R> {
-  const store = useContext(UploadContext)
-  if (!store || !isUploadStore<M, C, P, R>(store)) {
+  const store = useOptionalUploadStore<M, C, P, R>()
+  if (!store) {
     throw new Error('useUploadStore must be used within UploadProvider')
   }
   return store

package/src/react/use-uploader.tsx

@@ -11,7 +11,7 @@ import type {
   UploadResultBase,
 } from '../core'
 import type { UploadStore } from '../core/engine/store'
-import { useUploadStore } from './upload-provider'
+import { useOptionalUploadStore, useUploadStore } from './upload-provider'
 
 export function createUploadFactory<
   M extends IntentMap,
@@ -46,6 +46,22 @@ type Uploader<M extends IntentMap, C extends CursorMap<M>, P extends string, R e
   ready: UploadItem<M, C, P, R>[]
 }
 
+/**
+ * Stable action surface for React consumers that need imperative store access.
+ *
+ * This is declared explicitly instead of relying on an inferred object return
+ * type so the generated package declarations do not leak the internal generic
+ * names created by `store.on.bind(store)`.
+ */
+export type UploaderActions<
+  M extends IntentMap,
+  C extends CursorMap<M>,
+  P extends string,
+  R extends UploadResultBase = UploadResultBase,
+> = Pick<UploadStore<M, C, P, R>, 'dispatch' | 'on'> & {
+  store: UploadStore<M, C, P, R>
+}
+
 export function useUploader<
   M extends IntentMap,
   C extends CursorMap<M>,
@@ -63,8 +79,13 @@ export function useUploader<
   C extends CursorMap<M>,
   P extends string,
   R extends UploadResultBase = UploadResultBase,
->(_store?: UploadStore<M, C, P, R> | undefined) {
-  const store = _store ?? useUploadStore<M, C, P, R>()
+>(providedStore?: UploadStore<M, C, P, R> | undefined) {
+  const contextStore = useOptionalUploadStore<M, C, P, R>()
+  const store = providedStore ?? contextStore
+  if (!store) {
+    throw new Error('useUploader must be used within UploadProvider when no store argument is provided')
+  }
+
   const snapshot = React.useSyncExternalStore(
     store.subscribe.bind(store),
     store.getSnapshot.bind(store),
@@ -105,7 +126,7 @@ export function useUploaderActions<
   C extends CursorMap<M>,
   P extends string,
   R extends UploadResultBase = UploadResultBase,
->() {
+>(): UploaderActions<M, C, P, R> {
   const store = useUploadStore<M, C, P, R>()
 
   const dispatch = React.useMemo(() => store.dispatch.bind(store), [store])

package/src/strategies/multipart/index.ts

@@ -160,7 +160,7 @@ export function multipartStrategy<
               .map(([partNumber, v]) => ({ partNumber, etag: v.etag, size: v.size }))
               .sort((a, b) => a.partNumber - b.partNumber),
           }
-          ctx.persistCursor(snapshot as C["multipart"])
+          ctx.persistCursor(snapshot as C['multipart'])
           report()
         } catch (err) {
           inflightBytes.delete(p.partNumber)
@@ -236,7 +236,7 @@ export function multipartStrategy<
             .sort((a, b) => a.partNumber - b.partNumber),
           completed: true,
         }
-        ctx.persistCursor(snapshot as C["multipart"])
+        ctx.persistCursor(snapshot as C['multipart'])
       }
     },
   }