@gentleduck/upload 0.2.1 → 0.2.4

package/src/core/engine/store/store.libs.ts

@@ -32,7 +32,7 @@ export function isAutoStart<M extends IntentMap, C extends CursorMap<M>, P exten
   opts: StoreOptions<M, C, P, R>,
   purpose: P,
 ): boolean {
-  const v = opts.config.autoStart
+  const v = opts.config?.autoStart
   if (v === undefined) return false
   if (Array.isArray(v)) return v.includes(purpose)
   if (typeof v === 'function') return v(purpose)
@@ -73,7 +73,7 @@ export function normalizeError(err: unknown, customNormalizer?: (err: unknown) =
 
   // HTTP errors
   if (isRecord(err) && (typeof err.status === 'number' || typeof err.statusCode === 'number')) {
-    const status = typeof err.status === 'number' ? err.status : err.statusCode
+    const status = (typeof err.status === 'number' ? err.status : err.statusCode) as number
     const retryable = status >= 500 || status === 429
     return { code: 'http', status, message: String(msg), cause: err, retryable }
   }

package/src/core/engine/store/store.runtime.ts

@@ -91,7 +91,9 @@ export function createStoreRuntime<
     scheduling: false,
 
     notify() {
-      rt.listeners.forEach((l) => l())
+      rt.listeners.forEach((listener) => {
+        listener()
+      })
     },
 
     scheduleWork() {

package/src/core/engine/store/store.types.ts

@@ -138,7 +138,7 @@ export interface StoreOptions<
  *
  * Used to configure the upload store persistence layer.
  */
-export type DeserializeContext<M extends IntentMap, C extends CursorMap<M>, P extends string> = {
+export type DeserializeContext<M extends IntentMap, _C extends CursorMap<M>, P extends string> = {
   isPurpose?: (value: string) => value is P
   isIntent?: (value: unknown) => value is M[keyof M]
   hasStrategy: (value: string) => boolean

package/src/core/engine/validation/file.ts

@@ -36,7 +36,7 @@ export function validateFile<P extends string>(file: File, purpose: P, config: U
             if (type.endsWith('/*')) {
               // Wildcard match: 'image/*' matches 'image/jpeg', 'image/png', etc.
               const prefix = type.slice(0, -2).toLowerCase()
-              return mimeType.startsWith(prefix + '/')
+              return mimeType.startsWith(`${prefix}/`)
             }
             // Exact match
             return mimeType === type.toLowerCase()

package/src/core/persistence/persistence.ts

@@ -1,4 +1,4 @@
-import type { AnyCursor, CursorMap, IntentMap, UploadResultBase } from '../contracts'
+import type { AnyCursor, AnyIntent, CursorMap, IntentMap, UploadResultBase } from '../contracts'
 import type { UploadItem } from '../engine/internal-events.types'
 import type { UploadState } from '../engine/reducer'
 import { hasCursor, hasIntent } from '../engine/store/store.libs'
@@ -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 === 'completed' || item.phase === 'canceled' || item.phase === '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
 
@@ -116,13 +121,13 @@ export function deserializeSnapshot<
         lastModified: parsed.file.lastModified,
         checksum: parsed.file.checksum,
       },
-      intent: parsed.intent,
+      intent: parsed.intent as AnyIntent<M>,
       cursor: parsed.cursor,
       progress: { uploadedBytes, totalBytes, pct },
       pausedAt: Date.now(),
       createdAt: raw.createdAt ?? Date.now(),
       file: undefined,
-    })
+    } as UploadItem<M, C, P, R>)
   }
 
   return { items }

package/src/core/persistence/persistence.types.ts

@@ -41,7 +41,7 @@ export type PersistedUploadItem<M, C, P extends string> = {
   /** Backend-provided "intent" that describes how to upload (strategy, URLs, fields, etc). */
   intent: M[keyof M]
   /** Strategy cursor used to resume uploads that support continuation. */
-  cursor?: import('../contracts').AnyCursor<C>
+  cursor?: import('../contracts').AnyCursor<C & Record<string, unknown>>
   /** Last-known progress for UX continuity after restoring from persistence. */
   progress?: { uploadedBytes: number; totalBytes: number; pct?: number }
   /** The last known state-machine phase at the time of persistence. */

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

@@ -1,5 +1,7 @@
 import type { TypedEmitter } from './emitter.types'
 
+export type { TypedEmitter } from './emitter.types'
+
 /**
  * Creates a lightweight, typed event emitter.
  * We use this instead of `EventEmitter` or `EventTarget` to ensure:
@@ -28,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)
+          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)
+        ctx.persistCursor(snapshot as C['multipart'])
       }
     },
   }