@universal-uploader/core 1.0.0

package/dist/xhr-chuncked/index.js

@@ -0,0 +1,181 @@
+const HTTP_STATUS_SUCCESS_MIN = 200;
+const HTTP_STATUS_SUCCESS_MAX_EXCLUSIVE = 300;
+const isSuccessfulHttpStatus = (status) => status >= HTTP_STATUS_SUCCESS_MIN && status < HTTP_STATUS_SUCCESS_MAX_EXCLUSIVE;
+const getChunkUploadMeta = ({ chunkSize, fileSize, }) => {
+    const safeChunkSize = Math.max(1, chunkSize);
+    const totalFileSize = fileSize;
+    const totalChunks = Math.ceil(totalFileSize / safeChunkSize);
+    return {
+        safeChunkSize,
+        totalFileSize,
+        totalChunks,
+    };
+};
+const getChunkRange = ({ chunkIndex, safeChunkSize, totalFileSize, }) => {
+    const start = chunkIndex * safeChunkSize;
+    const end = Math.min(start + safeChunkSize, totalFileSize);
+    return {
+        start,
+        end,
+    };
+};
+const applyChunkHeaders = ({ xhr, customHeaders, chunkIndex, totalChunks, safeChunkSize, totalFileSize, }) => {
+    xhr.setRequestHeader('X-Chunk-Index', String(chunkIndex));
+    xhr.setRequestHeader('X-Total-Chunks', String(totalChunks));
+    xhr.setRequestHeader('X-Chunk-Size', String(safeChunkSize));
+    xhr.setRequestHeader('X-File-Size', String(totalFileSize));
+    Object.entries(customHeaders).forEach(([key, value]) => {
+        xhr.setRequestHeader(key, value);
+    });
+};
+const uploadWithoutChunking = ({ url, file, refresh, customHeaders, onProgress, }) => {
+    const xhr = new XMLHttpRequest();
+    const response = new Promise((resolve, reject) => {
+        xhr.open('POST', url);
+        Object.entries(customHeaders).forEach(([key, value]) => {
+            xhr.setRequestHeader(key, value);
+        });
+        if (onProgress) {
+            xhr.upload.onprogress = (event) => {
+                const total = event.total || file.size;
+                const percentage = total === 0 ? 100 : (event.loaded / total) * 100;
+                onProgress({
+                    loaded: event.loaded,
+                    total,
+                    percentage,
+                });
+            };
+        }
+        xhr.onload = () => {
+            if (isSuccessfulHttpStatus(xhr.status)) {
+                if (onProgress) {
+                    onProgress({ loaded: file.size, total: file.size, percentage: 100 });
+                }
+                resolve({
+                    ok: true,
+                    total: file.size,
+                    message: undefined,
+                    status: 'success',
+                });
+                return;
+            }
+            reject(new Error(`Upload failed with status ${xhr.status}`));
+        };
+        xhr.onerror = (e) => reject(e);
+        xhr.onabort = () => {
+            reject(new DOMException('Aborted', 'AbortError'));
+        };
+        xhr.send(file);
+    });
+    return {
+        result: response.then((res) => ({
+            ok: res.ok,
+            total: file.size,
+            message: undefined,
+            status: 'success',
+        })),
+        actions: {
+            abort: () => xhr.abort(),
+            refresh: () => {
+                xhr.abort();
+                refresh();
+            },
+        },
+    };
+};
+const uploadWithXhrChuncked = async ({ url, file, refresh, options: { chunkSize, customHeaders = {}, onProgress }, }) => {
+    const response = {
+        result: Promise.resolve({ ok: false, total: 0, message: undefined, status: 'idle' }),
+        actions: {
+            abort: () => null,
+            refresh: () => null,
+        },
+    };
+    if (!chunkSize || chunkSize <= 0) {
+        return uploadWithoutChunking({ url, file, refresh, customHeaders, onProgress });
+    }
+    const { safeChunkSize, totalFileSize, totalChunks } = getChunkUploadMeta({
+        chunkSize,
+        fileSize: file.size,
+    });
+    if (totalFileSize === 0) {
+        if (onProgress) {
+            onProgress({ loaded: 0, total: 0, percentage: 100 });
+        }
+        response.result = Promise.resolve({
+            ok: true,
+            total: 0,
+            message: undefined,
+            status: 'success',
+        });
+        return response;
+    }
+    const chunkUpload = async () => {
+        let uploadResult = {
+            ok: false,
+            total: 0,
+            message: undefined,
+            status: 'uploading',
+        };
+        for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex += 1) {
+            const { start, end } = getChunkRange({
+                chunkIndex,
+                safeChunkSize,
+                totalFileSize,
+            });
+            const uploadPromise = new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open('POST', url);
+                applyChunkHeaders({
+                    xhr,
+                    customHeaders,
+                    chunkIndex,
+                    totalChunks,
+                    safeChunkSize,
+                    totalFileSize,
+                });
+                xhr.onload = () => {
+                    if (isSuccessfulHttpStatus(xhr.status)) {
+                        const isLastChunk = end >= totalFileSize;
+                        const percentage = isLastChunk ? 100 : (end / totalFileSize) * 100;
+                        if (onProgress) {
+                            onProgress({
+                                loaded: end,
+                                total: totalFileSize,
+                                percentage: totalFileSize === 0 ? 100 : percentage,
+                            });
+                        }
+                        resolve({
+                            ok: true,
+                            total: totalFileSize,
+                            message: undefined,
+                            status: isLastChunk ? 'success' : 'uploading',
+                        });
+                        return;
+                    }
+                    reject(new Error(`Chunk upload failed with status ${xhr.status}`));
+                };
+                xhr.onerror = (e) => reject(e);
+                xhr.onabort = () => {
+                    const abortError = new DOMException('Aborted', 'AbortError');
+                    reject(abortError);
+                };
+                const chunk = file.slice(start, end);
+                xhr.send(chunk);
+                // 불변성을 보장하지 않고 클로저에서 변경하는 방식
+                response.actions.abort = () => xhr.abort();
+                response.actions.refresh = () => {
+                    xhr.abort();
+                    refresh();
+                };
+            });
+            // 불변성을 보장하지 않고 클로저에서 result 변경 (빠른 UX를 위해, chunkUpload의 action 먼저 반환하고 나머지는 클로저로 업데이트하는 방식)
+            // eslint-disable-next-line no-await-in-loop -- chunked mode intentionally uploads sequentially
+            uploadResult = await uploadPromise;
+        }
+        return uploadResult;
+    };
+    response.result = chunkUpload();
+    return response;
+};
+export default uploadWithXhrChuncked;

package/dist/xhr.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+var utils = require('./utils-B4LG-_oN.js');
+var index = require('./index-CZdguoWB.js');
+
+/**
+ * Orchestrates file upload by selecting the optimal method and managing retries and errors.
+ * 최적의 업로드 방식을 선택하고 재시도 및 에러 처리를 관리하여 파일 업로드를 수행합니다.
+ */
+const upload = async ({ url, file, options: { method = "xhr chunked", ...options } }, retryAttempt = 0) => {
+    const { onComplete, onProgress, onAbort, onRetry, onError, retryCount: retryCountArg = 3, retryDelay = 1000, throwOnError = false, ...restOptions } = options;
+    const retryCount = retryCountArg;
+    /**
+     * Determines whether to throw an error based on configuration.
+     * 구성 설정에 따라 에러를 throw할지 결정합니다.
+     */
+    const shouldThrowError = (e) => {
+        if (typeof throwOnError === "function") {
+            return throwOnError(e);
+        }
+        return Boolean(throwOnError);
+    };
+    /**
+     * Handles user-triggered aborts.
+     * 사용자에 의해 중단된 경우를 처리합니다.
+     */
+    const handleAbort = (e) => {
+        onAbort?.(e);
+        if (shouldThrowError(e)) {
+            throw e;
+        }
+        return {
+            ok: false,
+            total: 0,
+            message: "Aborted by user action",
+            status: "aborted",
+        };
+    };
+    /**
+     * Handles generic errors during upload.
+     * 업로드 중 발생하는 일반적인 에러를 처리합니다.
+     */
+    const handleError = (e) => {
+        onError?.(e);
+        if (shouldThrowError(e)) {
+            throw e;
+        }
+        return { ok: false, total: 0, message: e.message, status: "error" };
+    };
+    const finalOptions = {
+        ...restOptions,
+        onProgress: ({ loaded, total, percentage }) => {
+            onProgress?.({ loaded, total, percentage });
+            if (percentage === 100) {
+                onComplete?.();
+            }
+        },
+    };
+    const refresh = () => upload({ url, file, options });
+    /**
+     * Attempts to retry an upload operation.
+     * 업로드 작업을 재시도합니다.
+     */
+    const retryUpload = async (uploadArgs) => {
+        const nextRetryAttempt = retryAttempt + 1;
+        const nextRetryDelay = typeof retryDelay === "function"
+            ? retryDelay(nextRetryAttempt)
+            : retryDelay;
+        await utils.wait(nextRetryDelay);
+        const uploadResponse = await upload(uploadArgs, nextRetryAttempt);
+        onRetry?.();
+        return uploadResponse;
+    };
+    /**
+     * Wraps the upload operation with error and retry handling.
+     * 에러 처리 및 재시도 로직으로 업로드 작업을 래핑합니다.
+     */
+    const wrapPromiseErrorHandler = async (uploadResponse) => {
+        const { result: originalResult, actions: originalActions } = uploadResponse;
+        const retriedResult = originalResult
+            .then((uploadResult) => {
+            /**
+             * fetch resolves for HTTP 4xx/5xx, so stream mode can return { ok: false, status: 'error' }
+             * without rejecting. We rethrow here to route it through retry/onError handling.
+             *
+             * fetch는 HTTP 4xx/5xx에서도 reject하지 않아 stream 모드가 실패 결과를 resolve로 반환할 수 있습니다.
+             * 그래서 여기서 다시 throw해서 retry/onError 흐름으로 태웁니다.
+             */
+            if (!uploadResult.ok && uploadResult.status === "error") {
+                throw new Error(uploadResult.message || "Upload failed");
+            }
+            return uploadResult;
+        })
+            .catch(async (e) => {
+            if (e instanceof DOMException && e.name === "AbortError") {
+                return handleAbort(e);
+            }
+            if (retryCount > 0) {
+                const { result: retryResult, actions: retryActions } = await retryUpload({
+                    url,
+                    file,
+                    options: {
+                        ...options,
+                        method,
+                        retryCount: retryCount - 1,
+                    },
+                });
+                Object.assign(originalActions, retryActions);
+                return retryResult;
+            }
+            return handleError(e);
+        });
+        return { result: Promise.resolve(retriedResult), actions: originalActions };
+    };
+    try {
+        const uploadResult = await wrapPromiseErrorHandler(await index.uploadWithXhrChuncked({
+            url,
+            file,
+            refresh,
+            options: finalOptions,
+        }));
+        return uploadResult;
+    }
+    catch (e) {
+        onError?.(e);
+    }
+    return {
+        result: Promise.resolve({
+            ok: false,
+            total: 0,
+            message: "Unsupported upload method",
+            status: "error",
+        }),
+        actions: {
+            abort: () => null,
+            refresh,
+        },
+    };
+};
+
+module.exports = upload;
+//# sourceMappingURL=xhr.cjs.map

package/dist/xhr.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr.cjs","sources":["../src/xhr.ts"],"sourcesContent":["export * from \"./types\";\nimport {\n  Upload,\n  UploadResponse,\n  UploadResult,\n  OnProgressParams,\n} from \"./types\";\nimport { wait } from \"./utils\";\nimport uploadWithXhrChuncked from \"./xhr-chuncked\";\n\n/**\n * Orchestrates file upload by selecting the optimal method and managing retries and errors.\n * 최적의 업로드 방식을 선택하고 재시도 및 에러 처리를 관리하여 파일 업로드를 수행합니다.\n */\nconst upload = async (\n  { url, file, options: { method = \"xhr chunked\", ...options } }: Upload,\n  retryAttempt = 0,\n): Promise<UploadResponse> => {\n  const {\n    onComplete,\n    onProgress,\n    onAbort,\n    onRetry,\n    onError,\n    retryCount: retryCountArg = 3,\n    retryDelay = 1000,\n    throwOnError = false,\n    ...restOptions\n  } = options;\n\n  const retryCount = retryCountArg;\n\n  /**\n   * Determines whether to throw an error based on configuration.\n   * 구성 설정에 따라 에러를 throw할지 결정합니다.\n   */\n  const shouldThrowError = (e: unknown): boolean => {\n    if (typeof throwOnError === \"function\") {\n      return throwOnError(e);\n    }\n\n    return Boolean(throwOnError);\n  };\n\n  /**\n   * Handles user-triggered aborts.\n   * 사용자에 의해 중단된 경우를 처리합니다.\n   */\n  const handleAbort = (e: DOMException): UploadResult => {\n    onAbort?.(e);\n\n    if (shouldThrowError(e)) {\n      throw e;\n    }\n\n    return {\n      ok: false,\n      total: 0,\n      message: \"Aborted by user action\",\n      status: \"aborted\",\n    };\n  };\n\n  /**\n   * Handles generic errors during upload.\n   * 업로드 중 발생하는 일반적인 에러를 처리합니다.\n   */\n  const handleError = (e: Error): UploadResult => {\n    onError?.(e);\n\n    if (shouldThrowError(e)) {\n      throw e;\n    }\n\n    return { ok: false, total: 0, message: e.message, status: \"error\" };\n  };\n\n  const finalOptions = {\n    ...restOptions,\n    onProgress: ({ loaded, total, percentage }: OnProgressParams) => {\n      onProgress?.({ loaded, total, percentage });\n\n      if (percentage === 100) {\n        onComplete?.();\n      }\n    },\n  };\n\n  const refresh = () => upload({ url, file, options });\n\n  /**\n   * Attempts to retry an upload operation.\n   * 업로드 작업을 재시도합니다.\n   */\n  const retryUpload = async (uploadArgs: Upload): Promise<UploadResponse> => {\n    const nextRetryAttempt = retryAttempt + 1;\n\n    const nextRetryDelay =\n      typeof retryDelay === \"function\"\n        ? retryDelay(nextRetryAttempt)\n        : retryDelay;\n\n    await wait(nextRetryDelay);\n\n    const uploadResponse = await upload(uploadArgs, nextRetryAttempt);\n\n    onRetry?.();\n\n    return uploadResponse;\n  };\n\n  /**\n   * Wraps the upload operation with error and retry handling.\n   * 에러 처리 및 재시도 로직으로 업로드 작업을 래핑합니다.\n   */\n  const wrapPromiseErrorHandler = async (\n    uploadResponse: UploadResponse,\n  ): Promise<UploadResponse> => {\n    const { result: originalResult, actions: originalActions } = uploadResponse;\n\n    const retriedResult: Promise<UploadResult> = originalResult\n      .then((uploadResult) => {\n        /**\n         * fetch resolves for HTTP 4xx/5xx, so stream mode can return { ok: false, status: 'error' }\n         * without rejecting. We rethrow here to route it through retry/onError handling.\n         *\n         * fetch는 HTTP 4xx/5xx에서도 reject하지 않아 stream 모드가 실패 결과를 resolve로 반환할 수 있습니다.\n         * 그래서 여기서 다시 throw해서 retry/onError 흐름으로 태웁니다.\n         */\n        if (!uploadResult.ok && uploadResult.status === \"error\") {\n          throw new Error(uploadResult.message || \"Upload failed\");\n        }\n\n        return uploadResult;\n      })\n      .catch(async (e) => {\n        if (e instanceof DOMException && e.name === \"AbortError\") {\n          return handleAbort(e);\n        }\n\n        if (retryCount > 0) {\n          const { result: retryResult, actions: retryActions } =\n            await retryUpload({\n              url,\n              file,\n              options: {\n                ...options,\n                method,\n                retryCount: retryCount - 1,\n              },\n            });\n\n          Object.assign(originalActions, retryActions);\n          return retryResult;\n        }\n\n        return handleError(e as Error);\n      });\n\n    return { result: Promise.resolve(retriedResult), actions: originalActions };\n  };\n\n  try {\n    const uploadResult = await wrapPromiseErrorHandler(\n      await uploadWithXhrChuncked({\n        url,\n        file,\n        refresh,\n        options: finalOptions,\n      }),\n    );\n\n    return uploadResult;\n  } catch (e) {\n    onError?.(e as Error);\n  }\n\n  return {\n    result: Promise.resolve({\n      ok: false,\n      total: 0,\n      message: \"Unsupported upload method\",\n      status: \"error\",\n    }),\n    actions: {\n      abort: () => null,\n      refresh,\n    },\n  };\n};\n\nexport default upload;\n"],"names":["wait","uploadWithXhrChuncked"],"mappings":"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"}

package/dist/xhr.d.ts

@@ -0,0 +1,10 @@
+import { U as Upload, d as UploadResponse } from './types-CLZnJDsz.js';
+export { O as OnProgressParams, a as UploadActions, b as UploadOptions, c as UploadParams, e as UploadResult, f as UploadStatus } from './types-CLZnJDsz.js';
+
+/**
+ * Orchestrates file upload by selecting the optimal method and managing retries and errors.
+ * 최적의 업로드 방식을 선택하고 재시도 및 에러 처리를 관리하여 파일 업로드를 수행합니다.
+ */
+declare const upload: ({ url, file, options: { method, ...options } }: Upload, retryAttempt?: number) => Promise<UploadResponse>;
+
+export { Upload, UploadResponse, upload as default };

package/dist/xhr.js

@@ -0,0 +1,140 @@
+import { w as wait } from './utils-MtT6SgZa.js';
+import { u as uploadWithXhrChuncked } from './index-BS99wlKk.js';
+
+/**
+ * Orchestrates file upload by selecting the optimal method and managing retries and errors.
+ * 최적의 업로드 방식을 선택하고 재시도 및 에러 처리를 관리하여 파일 업로드를 수행합니다.
+ */
+const upload = async ({ url, file, options: { method = "xhr chunked", ...options } }, retryAttempt = 0) => {
+    const { onComplete, onProgress, onAbort, onRetry, onError, retryCount: retryCountArg = 3, retryDelay = 1000, throwOnError = false, ...restOptions } = options;
+    const retryCount = retryCountArg;
+    /**
+     * Determines whether to throw an error based on configuration.
+     * 구성 설정에 따라 에러를 throw할지 결정합니다.
+     */
+    const shouldThrowError = (e) => {
+        if (typeof throwOnError === "function") {
+            return throwOnError(e);
+        }
+        return Boolean(throwOnError);
+    };
+    /**
+     * Handles user-triggered aborts.
+     * 사용자에 의해 중단된 경우를 처리합니다.
+     */
+    const handleAbort = (e) => {
+        onAbort?.(e);
+        if (shouldThrowError(e)) {
+            throw e;
+        }
+        return {
+            ok: false,
+            total: 0,
+            message: "Aborted by user action",
+            status: "aborted",
+        };
+    };
+    /**
+     * Handles generic errors during upload.
+     * 업로드 중 발생하는 일반적인 에러를 처리합니다.
+     */
+    const handleError = (e) => {
+        onError?.(e);
+        if (shouldThrowError(e)) {
+            throw e;
+        }
+        return { ok: false, total: 0, message: e.message, status: "error" };
+    };
+    const finalOptions = {
+        ...restOptions,
+        onProgress: ({ loaded, total, percentage }) => {
+            onProgress?.({ loaded, total, percentage });
+            if (percentage === 100) {
+                onComplete?.();
+            }
+        },
+    };
+    const refresh = () => upload({ url, file, options });
+    /**
+     * Attempts to retry an upload operation.
+     * 업로드 작업을 재시도합니다.
+     */
+    const retryUpload = async (uploadArgs) => {
+        const nextRetryAttempt = retryAttempt + 1;
+        const nextRetryDelay = typeof retryDelay === "function"
+            ? retryDelay(nextRetryAttempt)
+            : retryDelay;
+        await wait(nextRetryDelay);
+        const uploadResponse = await upload(uploadArgs, nextRetryAttempt);
+        onRetry?.();
+        return uploadResponse;
+    };
+    /**
+     * Wraps the upload operation with error and retry handling.
+     * 에러 처리 및 재시도 로직으로 업로드 작업을 래핑합니다.
+     */
+    const wrapPromiseErrorHandler = async (uploadResponse) => {
+        const { result: originalResult, actions: originalActions } = uploadResponse;
+        const retriedResult = originalResult
+            .then((uploadResult) => {
+            /**
+             * fetch resolves for HTTP 4xx/5xx, so stream mode can return { ok: false, status: 'error' }
+             * without rejecting. We rethrow here to route it through retry/onError handling.
+             *
+             * fetch는 HTTP 4xx/5xx에서도 reject하지 않아 stream 모드가 실패 결과를 resolve로 반환할 수 있습니다.
+             * 그래서 여기서 다시 throw해서 retry/onError 흐름으로 태웁니다.
+             */
+            if (!uploadResult.ok && uploadResult.status === "error") {
+                throw new Error(uploadResult.message || "Upload failed");
+            }
+            return uploadResult;
+        })
+            .catch(async (e) => {
+            if (e instanceof DOMException && e.name === "AbortError") {
+                return handleAbort(e);
+            }
+            if (retryCount > 0) {
+                const { result: retryResult, actions: retryActions } = await retryUpload({
+                    url,
+                    file,
+                    options: {
+                        ...options,
+                        method,
+                        retryCount: retryCount - 1,
+                    },
+                });
+                Object.assign(originalActions, retryActions);
+                return retryResult;
+            }
+            return handleError(e);
+        });
+        return { result: Promise.resolve(retriedResult), actions: originalActions };
+    };
+    try {
+        const uploadResult = await wrapPromiseErrorHandler(await uploadWithXhrChuncked({
+            url,
+            file,
+            refresh,
+            options: finalOptions,
+        }));
+        return uploadResult;
+    }
+    catch (e) {
+        onError?.(e);
+    }
+    return {
+        result: Promise.resolve({
+            ok: false,
+            total: 0,
+            message: "Unsupported upload method",
+            status: "error",
+        }),
+        actions: {
+            abort: () => null,
+            refresh,
+        },
+    };
+};
+
+export { upload as default };
+//# sourceMappingURL=xhr.js.map

package/dist/xhr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr.js","sources":["../src/xhr.ts"],"sourcesContent":["export * from \"./types\";\nimport {\n  Upload,\n  UploadResponse,\n  UploadResult,\n  OnProgressParams,\n} from \"./types\";\nimport { wait } from \"./utils\";\nimport uploadWithXhrChuncked from \"./xhr-chuncked\";\n\n/**\n * Orchestrates file upload by selecting the optimal method and managing retries and errors.\n * 최적의 업로드 방식을 선택하고 재시도 및 에러 처리를 관리하여 파일 업로드를 수행합니다.\n */\nconst upload = async (\n  { url, file, options: { method = \"xhr chunked\", ...options } }: Upload,\n  retryAttempt = 0,\n): Promise<UploadResponse> => {\n  const {\n    onComplete,\n    onProgress,\n    onAbort,\n    onRetry,\n    onError,\n    retryCount: retryCountArg = 3,\n    retryDelay = 1000,\n    throwOnError = false,\n    ...restOptions\n  } = options;\n\n  const retryCount = retryCountArg;\n\n  /**\n   * Determines whether to throw an error based on configuration.\n   * 구성 설정에 따라 에러를 throw할지 결정합니다.\n   */\n  const shouldThrowError = (e: unknown): boolean => {\n    if (typeof throwOnError === \"function\") {\n      return throwOnError(e);\n    }\n\n    return Boolean(throwOnError);\n  };\n\n  /**\n   * Handles user-triggered aborts.\n   * 사용자에 의해 중단된 경우를 처리합니다.\n   */\n  const handleAbort = (e: DOMException): UploadResult => {\n    onAbort?.(e);\n\n    if (shouldThrowError(e)) {\n      throw e;\n    }\n\n    return {\n      ok: false,\n      total: 0,\n      message: \"Aborted by user action\",\n      status: \"aborted\",\n    };\n  };\n\n  /**\n   * Handles generic errors during upload.\n   * 업로드 중 발생하는 일반적인 에러를 처리합니다.\n   */\n  const handleError = (e: Error): UploadResult => {\n    onError?.(e);\n\n    if (shouldThrowError(e)) {\n      throw e;\n    }\n\n    return { ok: false, total: 0, message: e.message, status: \"error\" };\n  };\n\n  const finalOptions = {\n    ...restOptions,\n    onProgress: ({ loaded, total, percentage }: OnProgressParams) => {\n      onProgress?.({ loaded, total, percentage });\n\n      if (percentage === 100) {\n        onComplete?.();\n      }\n    },\n  };\n\n  const refresh = () => upload({ url, file, options });\n\n  /**\n   * Attempts to retry an upload operation.\n   * 업로드 작업을 재시도합니다.\n   */\n  const retryUpload = async (uploadArgs: Upload): Promise<UploadResponse> => {\n    const nextRetryAttempt = retryAttempt + 1;\n\n    const nextRetryDelay =\n      typeof retryDelay === \"function\"\n        ? retryDelay(nextRetryAttempt)\n        : retryDelay;\n\n    await wait(nextRetryDelay);\n\n    const uploadResponse = await upload(uploadArgs, nextRetryAttempt);\n\n    onRetry?.();\n\n    return uploadResponse;\n  };\n\n  /**\n   * Wraps the upload operation with error and retry handling.\n   * 에러 처리 및 재시도 로직으로 업로드 작업을 래핑합니다.\n   */\n  const wrapPromiseErrorHandler = async (\n    uploadResponse: UploadResponse,\n  ): Promise<UploadResponse> => {\n    const { result: originalResult, actions: originalActions } = uploadResponse;\n\n    const retriedResult: Promise<UploadResult> = originalResult\n      .then((uploadResult) => {\n        /**\n         * fetch resolves for HTTP 4xx/5xx, so stream mode can return { ok: false, status: 'error' }\n         * without rejecting. We rethrow here to route it through retry/onError handling.\n         *\n         * fetch는 HTTP 4xx/5xx에서도 reject하지 않아 stream 모드가 실패 결과를 resolve로 반환할 수 있습니다.\n         * 그래서 여기서 다시 throw해서 retry/onError 흐름으로 태웁니다.\n         */\n        if (!uploadResult.ok && uploadResult.status === \"error\") {\n          throw new Error(uploadResult.message || \"Upload failed\");\n        }\n\n        return uploadResult;\n      })\n      .catch(async (e) => {\n        if (e instanceof DOMException && e.name === \"AbortError\") {\n          return handleAbort(e);\n        }\n\n        if (retryCount > 0) {\n          const { result: retryResult, actions: retryActions } =\n            await retryUpload({\n              url,\n              file,\n              options: {\n                ...options,\n                method,\n                retryCount: retryCount - 1,\n              },\n            });\n\n          Object.assign(originalActions, retryActions);\n          return retryResult;\n        }\n\n        return handleError(e as Error);\n      });\n\n    return { result: Promise.resolve(retriedResult), actions: originalActions };\n  };\n\n  try {\n    const uploadResult = await wrapPromiseErrorHandler(\n      await uploadWithXhrChuncked({\n        url,\n        file,\n        refresh,\n        options: finalOptions,\n      }),\n    );\n\n    return uploadResult;\n  } catch (e) {\n    onError?.(e as Error);\n  }\n\n  return {\n    result: Promise.resolve({\n      ok: false,\n      total: 0,\n      message: \"Unsupported upload method\",\n      status: \"error\",\n    }),\n    actions: {\n      abort: () => null,\n      refresh,\n    },\n  };\n};\n\nexport default upload;\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@universal-uploader/core",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Core streaming upload logic.",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jdy8739/universal-uploader.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "upload",
+    "stream",
+    "fetch",
+    "xhr"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "rollup -c rollup.config.mjs",
+    "type-check": "tsc --noEmit"
+  }
+}