@open-dy/vibecoding-sdk-taro 0.1.11 → 0.1.13

package/src/runtime/prepared-upload-task.ts

@@ -0,0 +1,86 @@
+type UploadTask = ReturnType<typeof Taro.uploadFile>
+type ProgressCallback = Parameters<UploadTask['onProgressUpdate']>[0]
+type HeadersCallback = Parameters<UploadTask['onHeadersReceived']>[0]
+
+export function startPreparedUploadTask(
+  option: Taro.uploadFile.Option,
+  preparedPath: Promise<string>,
+  start: (option: Taro.uploadFile.Option) => UploadTask,
+): UploadTask {
+  let nativeTask: UploadTask | undefined
+  let abortBeforeStart: (() => void) | undefined
+  const progressListeners = new Set<ProgressCallback>()
+  const headersListeners = new Set<HeadersCallback>()
+
+  const onProgressUpdate = (callback: ProgressCallback) => {
+    if (nativeTask?.onProgressUpdate) nativeTask.onProgressUpdate(callback)
+    else if (nativeTask) nativeTask.progress?.(callback)
+    else if (abortBeforeStart) progressListeners.add(callback)
+  }
+  const onHeadersReceived = (callback: HeadersCallback) => {
+    if (nativeTask?.onHeadersReceived) nativeTask.onHeadersReceived(callback)
+    else if (nativeTask) nativeTask.headersReceive?.(callback)
+    else if (abortBeforeStart) headersListeners.add(callback)
+  }
+  const clearListeners = () => {
+    progressListeners.clear()
+    headersListeners.clear()
+  }
+
+  const promise = new Promise<Taro.uploadFile.SuccessCallbackResult>((resolve, reject) => {
+    abortBeforeStart = () => {
+      abortBeforeStart = undefined
+      clearListeners()
+      const error = { errMsg: 'uploadFile:fail upload file abort', errNo: 121905 }
+      reject(error)
+      try {
+        option.fail?.(error)
+      } finally {
+        option.complete?.(error)
+      }
+    }
+
+    void preparedPath.catch(() => option.filePath).then(filePath => {
+      if (!abortBeforeStart) return
+      abortBeforeStart = undefined
+      try {
+        nativeTask = start({ ...option, filePath })
+        resolve(nativeTask)
+        progressListeners.forEach(onProgressUpdate)
+        headersListeners.forEach(onHeadersReceived)
+      } finally {
+        clearListeners()
+      }
+    }).catch(reject)
+  })
+
+  const task: UploadTask = Object.assign(promise, {
+    abort(callback?: () => void) {
+      if (nativeTask || abortBeforeStart) callback?.()
+      if (nativeTask) nativeTask.abort?.()
+      else abortBeforeStart?.()
+      return task
+    },
+    onProgressUpdate,
+    offProgressUpdate(callback: ProgressCallback) {
+      if (callback) progressListeners.delete(callback)
+      else progressListeners.clear()
+      nativeTask?.offProgressUpdate?.(callback)
+    },
+    onHeadersReceived,
+    offHeadersReceived(callback: HeadersCallback) {
+      if (callback) headersListeners.delete(callback)
+      else headersListeners.clear()
+      nativeTask?.offHeadersReceived?.(callback)
+    },
+    progress(callback: ProgressCallback) {
+      onProgressUpdate(callback)
+      return task
+    },
+    headersReceive(callback: HeadersCallback) {
+      onHeadersReceived(callback)
+      return task
+    },
+  })
+  return task
+}