@knime/product-features 2.2.2 → 2.3.0

package/dist/core-CVWznjtP.js

@@ -0,0 +1,739 @@
+import { c as promise_exports, l as sleep, o as getFileMimeType } from "./dist-DvDWkkNg.js";
+import { ofetch } from "ofetch";
+//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+/**
+* Checks if a given value is a plain object.
+*
+* @param value - The value to check.
+* @returns True if the value is a plain object, otherwise false.
+*
+* @example
+* ```typescript
+* // ✅👇 True
+*
+* isPlainObject({ });                       // ✅
+* isPlainObject({ key: 'value' });          // ✅
+* isPlainObject({ key: new Date() });       // ✅
+* isPlainObject(new Object());              // ✅
+* isPlainObject(Object.create(null));       // ✅
+* isPlainObject({ nested: { key: true} });  // ✅
+* isPlainObject(new Proxy({}, {}));         // ✅
+* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
+*
+* // ✅👇 (cross-realms, node context, workers, ...)
+* const runInNewContext = await import('node:vm').then(
+*     (mod) => mod.runInNewContext
+* );
+* isPlainObject(runInNewContext('({})'));   // ✅
+*
+* // ❌👇 False
+*
+* class Test { };
+* isPlainObject(new Test())           // ❌
+* isPlainObject(10);                  // ❌
+* isPlainObject(null);                // ❌
+* isPlainObject('hello');             // ❌
+* isPlainObject([]);                  // ❌
+* isPlainObject(new Date());          // ❌
+* isPlainObject(new Uint8Array([1])); // ❌
+* isPlainObject(Buffer.from('ABC'));  // ❌
+* isPlainObject(Promise.resolve({})); // ❌
+* isPlainObject(Object.create({}));   // ❌
+* isPlainObject(new (class Cls {}));  // ❌
+* isPlainObject(globalThis);          // ❌,
+* ```
+*/
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+/**
+* Checks if a property key is unsafe to modify directly.
+*
+* This function is used in functions like `merge` to prevent prototype pollution attacks
+* by identifying property keys that could modify the object's prototype chain or constructor.
+*
+* @param key - The property key to check
+* @returns `true` if the property is unsafe to modify directly, `false` otherwise
+* @internal
+*/
+function isUnsafeProperty(key) {
+	return key === "__proto__";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/object/merge.mjs
+/**
+* Merges the properties of the source object into the target object.
+*
+* This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+* If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged.
+* If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+*
+* Note that this function mutates the target object.
+*
+* @param target - The target object into which the source object properties will be merged. This object is modified in place.
+* @param source - The source object whose properties will be merged into the target object.
+* @returns The updated target object with properties from the source object merged in.
+*
+* @template T - Type of the target object.
+* @template S - Type of the source object.
+*
+* @example
+* const target = { a: 1, b: { x: 1, y: 2 } };
+* const source = { b: { y: 3, z: 4 }, c: 5 };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+*
+* @example
+* const target = { a: [1, 2], b: { x: 1 } };
+* const source = { a: [3], b: { y: 2 } };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+*
+* @example
+* const target = { a: null };
+* const source = { a: [1, 2, 3] };
+*
+* const result = merge(target, source);
+* console.log(result);
+* // Output: { a: [1, 2, 3] }
+*/
+function merge(target, source) {
+	const sourceKeys = Object.keys(source);
+	for (let i = 0; i < sourceKeys.length; i++) {
+		const key = sourceKeys[i];
+		if (isUnsafeProperty(key)) continue;
+		const sourceValue = source[key];
+		const targetValue = target[key];
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
+		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
+		else if (isPlainObject(sourceValue)) target[key] = merge({}, sourceValue);
+		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
+	}
+	return target;
+}
+function isMergeableValue(value) {
+	return isPlainObject(value) || Array.isArray(value);
+}
+//#endregion
+//#region src/dataTransfer/shared/httpClient/constants.ts
+var API_BASE_URL = "/_/api";
+//#endregion
+//#region src/dataTransfer/shared/httpClient/createHttpClient.ts
+var defaultConfig = {
+	baseURL: API_BASE_URL,
+	headers: {
+		"Content-Type": "application/json",
+		Accept: "application/json; application/problem+json"
+	}
+};
+var createHttpClient = (customOptions) => {
+	const { baseURL = API_BASE_URL, ...otherCustomOptions } = customOptions ?? {};
+	return ofetch.create(merge({
+		baseURL,
+		...otherCustomOptions
+	}, defaultConfig));
+};
+//#endregion
+//#region src/dataTransfer/upload/core/uploadManager/config.ts
+/**
+* Configuration constants shared by the upload managers
+*/
+var CONFIG = Object.freeze({
+	/** Size, in bytes, of each uploaded file part. */
+	CHUNK_SIZE: 50 * 1024 * 1024,
+	/** Max number of retries for a failed request (part-url resolution or the chunk upload itself). */
+	DEFAULT_RETRY_COUNT: 5,
+	/** Delay, in ms, between retries. */
+	DEFAULT_RETRY_DELAY_MS: 50
+});
+//#endregion
+//#region src/dataTransfer/upload/core/uploadManager/state.ts
+var createStateManager = () => {
+	const uploadStateMap = /* @__PURE__ */ new Map();
+	const completedUploads = /* @__PURE__ */ new Set();
+	const cancelledUploads = /* @__PURE__ */ new Set();
+	const failedUploads = /* @__PURE__ */ new Set();
+	const assertState = (uploadId, state) => uploadStateMap.has(uploadId) && uploadStateMap.get(uploadId).state === state;
+	const getUploadState = (uploadId) => uploadStateMap.get(uploadId);
+	const setUploadState = (uploadId, state) => {
+		uploadStateMap.set(uploadId, {
+			...uploadStateMap.get(uploadId),
+			...state
+		});
+	};
+	const isFailed = (uploadId) => assertState(uploadId, "failed");
+	const isCancelled = (uploadId) => assertState(uploadId, "cancelled");
+	const abortInFlightUpload = (uploadId, reason) => {
+		const currentState = uploadStateMap.get(uploadId);
+		if (!currentState) return;
+		const message = currentState.fileDescriptor ? `Upload (${currentState.uploadId}) for file "${currentState.fileDescriptor.name}" aborted. Reason: "${reason}"` : `Upload (${currentState.uploadId}) aborted. Reason: "${reason}"`;
+		currentState.abortController.abort(new promise_exports.AbortError(message));
+	};
+	const cancel = (uploadId) => {
+		if (!uploadStateMap.has(uploadId)) {
+			consola.error("cancel:: Invalid upload id");
+			return;
+		}
+		setUploadState(uploadId, { state: "cancelled" });
+		abortInFlightUpload(uploadId, "upload cancelled");
+		cancelledUploads.add(uploadId);
+	};
+	const cancelAll = () => {
+		for (const [id, upload] of uploadStateMap.entries()) if (upload.state === "inprogress") cancel(id);
+	};
+	const setCompleted = (uploadId, completedChunkCount) => {
+		setUploadState(uploadId, {
+			completedChunkCount,
+			state: "complete"
+		});
+		completedUploads.add(uploadId);
+	};
+	const setFailed = (uploadId) => {
+		if (!uploadStateMap.has(uploadId)) {
+			consola.error("failed:: Invalid upload id");
+			return;
+		}
+		setUploadState(uploadId, { state: "failed" });
+		failedUploads.add(uploadId);
+		if (completedUploads.has(uploadId)) completedUploads.delete(uploadId);
+	};
+	const flush = () => {
+		const completed = [...completedUploads.values()];
+		const cancelled = [...cancelledUploads.values()];
+		const failed = [...failedUploads.values()];
+		[
+			...completed,
+			...cancelled,
+			...failed
+		].forEach((uploadId) => uploadStateMap.delete(uploadId));
+		completedUploads.clear();
+		cancelledUploads.clear();
+		failedUploads.clear();
+		return {
+			completed,
+			cancelled,
+			failed
+		};
+	};
+	return {
+		get: getUploadState,
+		set: setUploadState,
+		isFailed,
+		isCancelled,
+		cancel,
+		cancelAll,
+		setCompleted,
+		setFailed,
+		abortInFlightUpload,
+		flush
+	};
+};
+//#endregion
+//#region src/dataTransfer/upload/core/uploadManager/uploadPartBytes.ts
+/**
+* Uploads a single file part via XHR, reporting upload progress and
+* resolving with the part's identifying ETag (or an empty string if the
+* backend doesn't return one).
+*/
+var uploadPartBytesWithProgress = (params) => {
+	const { method, url, partBytes, partIndex, onProgress, abortSignal } = params;
+	const OK = 200;
+	const CREATED = 201;
+	return new Promise((resolve, reject) => {
+		const xhr = new XMLHttpRequest();
+		xhr.open(method, url, true);
+		abortSignal.addEventListener("abort", () => xhr.abort());
+		xhr.upload.onprogress = (event) => {
+			if (event.lengthComputable) onProgress(event.loaded);
+		};
+		xhr.onload = () => {
+			if (xhr.status === OK || xhr.status === CREATED) resolve({ partId: xhr.getResponseHeader("ETag")?.replace(/^(?:W\/)?"|"$/g, "") ?? "" });
+			else {
+				consola.error("Failed or unexpected XHR response", {
+					xhrStatus: xhr.status,
+					xhrResponse: xhr.response,
+					partIndex
+				});
+				reject(/* @__PURE__ */ new Error("Failed to upload file"));
+			}
+		};
+		xhr.onerror = (event) => {
+			consola.error("Failed to upload part", {
+				xhrErrorEvent: event,
+				partIndex
+			});
+			reject(/* @__PURE__ */ new Error("Failed to upload file"));
+		};
+		xhr.send(partBytes);
+	});
+};
+//#endregion
+//#region src/dataTransfer/upload/core/uploadManager/chunkedUploadManager.ts
+/**
+* Creates and returns an `uploadManager`, a comprehensive multi-file, multi-part upload handler.
+*
+* The `uploadManager` offers functionality for handling file uploads in parts and provides
+* several built-in mechanisms to ensure the process is reliable and adaptable.
+*
+* Key features include:
+*
+* - **Chunked File Uploads**: Splits provided files into manageable chunks and initiates the upload
+*   for each part using the `resolveFilePartUploadURL` function provided in the configuration.
+*
+* - **Retry Mechanism**: Automatically retries failed upload attempts up to a maximum of 5 times
+*   per failed request.
+*
+* - **Upload Cancellation**: Allows cancellation of ongoing uploads, giving users control over the process.
+*
+* - **Progress Tracking**: Monitors the progress of each file part upload and triggers the `onProgress`
+*   callback to provide updates.
+*
+* - **Error Handling**: The returned `uploadFiles` function does not throw errors directly. Instead,
+*   it manages retries and stops any failed uploads after the retry limit is reached, marking them as failed.
+*   This ensures that the promise it returns completes gracefully without uncaught exceptions.
+*
+* This is the "slice-based" manager: it needs each file's complete bytes to already be
+* available (as a real `File`/`Blob` with a known `.size`), since it produces each part via
+* `file.slice()`. For uploading from a source whose total size isn't known upfront (e.g. a
+* stream of compressed output), see `createStreamingUploadManager` instead.
+*/
+var createUploadManager = (config) => {
+	const { resolveFilePartUploadURL: getUploadFilePartUrl, onFileUploadComplete, onFileUploadFailed } = config;
+	const state = createStateManager();
+	const getTotalFileParts = (file) => Math.ceil(file.size / CONFIG.CHUNK_SIZE);
+	const uploadFileFromChunkIndex = async (uploadId, file) => {
+		const totalChunks = getTotalFileParts(file);
+		const totalBytes = file.size;
+		const completedPartIds = {};
+		const { abortController, runAbortablePromise } = promise_exports.createAbortablePromise();
+		state.set(uploadId, {
+			uploadId,
+			fileDescriptor: {
+				name: file.name,
+				type: file.type
+			},
+			state: "inprogress",
+			uploadedByteCount: state.get(uploadId)?.uploadedByteCount ?? 0,
+			completedChunkCount: state.get(uploadId)?.completedChunkCount ?? 0,
+			abortController
+		});
+		let chunkIndex = 0;
+		let uploadedBytes = state.get(uploadId)?.uploadedByteCount;
+		while (chunkIndex < totalChunks) {
+			if (state.isCancelled(uploadId) || state.isFailed(uploadId)) break;
+			const start = chunkIndex * CONFIG.CHUNK_SIZE;
+			const end = Math.min(start + CONFIG.CHUNK_SIZE, file.size);
+			const chunk = file.slice(start, end);
+			try {
+				const { method, url } = await promise_exports.retryPromise({
+					fn: () => getUploadFilePartUrl(uploadId, chunkIndex + 1),
+					retryCount: CONFIG.DEFAULT_RETRY_COUNT,
+					retryDelayMS: CONFIG.DEFAULT_RETRY_DELAY_MS
+				});
+				consola.trace("File part upload url resolved", {
+					method,
+					url
+				});
+				const onChunkUploadProgress = (uploadedChunkBytes) => {
+					uploadedBytes = uploadedChunkBytes + start;
+					state.set(uploadId, { uploadedByteCount: uploadedBytes });
+					const progress = Math.round(uploadedBytes / totalBytes * 100);
+					config.onProgress?.(uploadId, progress);
+				};
+				const filePartResponse = await runAbortablePromise(() => promise_exports.retryPromise({
+					fn: () => uploadPartBytesWithProgress({
+						method,
+						url,
+						partBytes: chunk,
+						partIndex: chunkIndex,
+						onProgress: onChunkUploadProgress,
+						abortSignal: abortController.signal
+					}),
+					retryCount: CONFIG.DEFAULT_RETRY_COUNT,
+					retryDelayMS: CONFIG.DEFAULT_RETRY_DELAY_MS
+				}));
+				consola.trace(`${file.name}: Chunk ${chunkIndex + 1} of ${totalChunks} uploaded successfully`);
+				completedPartIds[chunkIndex + 1] = filePartResponse.partId;
+				state.set(uploadId, { completedChunkCount: state.get(uploadId).completedChunkCount + 1 });
+			} catch (_error) {
+				if (_error instanceof promise_exports.AbortError) {
+					consola.info("Aborted::", _error);
+					return;
+				}
+				const error = _error instanceof Error ? _error : new Error(_error);
+				state.setFailed(uploadId);
+				onFileUploadFailed?.({
+					uploadId,
+					error
+				});
+				return;
+			}
+			chunkIndex++;
+		}
+		if (state.isCancelled(uploadId) || state.isFailed(uploadId)) return;
+		state.setCompleted(uploadId, totalChunks);
+		onFileUploadComplete?.({
+			uploadId,
+			filePartIds: completedPartIds
+		});
+	};
+	const uploadFiles = (files) => {
+		const result = [];
+		for (const { uploadId, file } of files) result.push(uploadFileFromChunkIndex(uploadId, file));
+		return Promise.allSettled(result).then(() => state.flush());
+	};
+	return {
+		uploadFiles,
+		getUploadState: state.get,
+		isFailed: state.isFailed,
+		isCancelled: state.isCancelled,
+		cancel: state.cancel,
+		cancelAll: state.cancelAll,
+		setFailed: state.setFailed
+	};
+};
+//#endregion
+//#region src/dataTransfer/upload/core/uploadManager/streamingUploadManager.ts
+/**
+* A small FIFO byte buffer. Pushed chunks are stored by reference (no
+* copying on push).
+*/
+var ByteQueue = class {
+	#chunks = [];
+	#length = 0;
+	get length() {
+		return this.#length;
+	}
+	push(chunk) {
+		if (chunk.length === 0) return;
+		this.#chunks.push(chunk);
+		this.#length += chunk.length;
+	}
+	/**
+	* FIFO exactly `n` bytes from the buffer. If the first chunk has more bytes than needed,
+	* it will be split and only the requested amount returned. This ensures each byte is copied
+	* at most once, regardless of how many small chunks it took to accumulate them.
+	* @param n
+	* @returns
+	*/
+	take(n) {
+		const size = Math.min(n, this.#length);
+		const result = new Uint8Array(size);
+		let offset = 0;
+		while (offset < size) {
+			const chunk = this.#chunks[0];
+			const needed = size - offset;
+			if (chunk.length <= needed) {
+				result.set(chunk, offset);
+				offset += chunk.length;
+				this.#chunks.shift();
+			} else {
+				result.set(chunk.subarray(0, needed), offset);
+				this.#chunks[0] = chunk.subarray(needed);
+				offset += needed;
+			}
+		}
+		this.#length -= size;
+		return result;
+	}
+	takeAll() {
+		return this.take(this.#length);
+	}
+};
+var readStreamAndUpload = async (state, uploadId, stream, uploadPart, config) => {
+	const buffer = new ByteQueue();
+	const reader = stream.getReader();
+	const closeReader = async () => {
+		try {
+			await reader.cancel();
+		} catch {} finally {
+			reader.releaseLock();
+		}
+	};
+	try {
+		while (true) {
+			if (state.isCancelled(uploadId) || state.isFailed(uploadId)) return;
+			const { value, done } = await reader.read();
+			if (value) buffer.push(value);
+			while (buffer.length >= CONFIG.CHUNK_SIZE) {
+				if (state.isCancelled(uploadId) || state.isFailed(uploadId)) return;
+				await uploadPart(buffer.take(CONFIG.CHUNK_SIZE));
+			}
+			if (done) {
+				if (buffer.length > 0 && !state.isCancelled(uploadId) && !state.isFailed(uploadId)) await uploadPart(buffer.takeAll());
+				break;
+			}
+		}
+	} catch (_error) {
+		if (_error instanceof promise_exports.AbortError) {
+			consola.info("Aborted::", _error);
+			return;
+		}
+		state.setFailed(uploadId);
+		const error = _error instanceof Error ? _error : new Error(_error);
+		config.onFileUploadFailed?.({
+			uploadId,
+			error
+		});
+	} finally {
+		await closeReader();
+	}
+};
+/**
+* Creates and returns a `streamingUploadManager` - a multi-part upload handler
+* driven by a `ReadableStream<Uint8Array>` rather than a `File`/`Blob`.
+*
+* Unlike the chunkedUploadManager, this doesn't need to know the total size of the upload upfront.
+* Instead, it accumulates stream chunks into a buffer and uploadsa part every time
+* the buffer crosses the configured threshold for upload chunks, flushing whatever remains
+* as a final (possibly smaller) part once the stream ends.
+*
+* This bounds memory to roughly one chunk's worth of buffered bytes, plus
+* whatever the stream source itself buffers, regardless of the eventual
+* total size - useful for sources whose size can't be known in advance,
+* such as compressed output from a streaming zip encoder.
+*
+* Shares the same part-upload mechanics (retries, progress, abort) as
+* the chunkedUploadManager
+*/
+var createStreamingUploadManager = (config) => {
+	const { resolveFilePartUploadURL: getUploadFilePartUrl, onFileUploadComplete } = config;
+	const state = createStateManager();
+	const uploadStreamFromPartIndex = async (uploadId, stream) => {
+		const completedPartIds = {};
+		const { abortController, runAbortablePromise } = promise_exports.createAbortablePromise();
+		state.set(uploadId, {
+			uploadId,
+			state: "inprogress",
+			uploadedByteCount: state.get(uploadId)?.uploadedByteCount ?? 0,
+			completedChunkCount: state.get(uploadId)?.completedChunkCount ?? 0,
+			abortController
+		});
+		let partIndex = 0;
+		let uploadedBytes = state.get(uploadId)?.uploadedByteCount ?? 0;
+		const uploadPart = async (bytes) => {
+			const chunk = new Blob([bytes]);
+			const { method, url } = await promise_exports.retryPromise({
+				fn: () => getUploadFilePartUrl(uploadId, partIndex + 1),
+				retryCount: CONFIG.DEFAULT_RETRY_COUNT,
+				retryDelayMS: CONFIG.DEFAULT_RETRY_DELAY_MS
+			});
+			const uploadedBeforeThisPart = uploadedBytes;
+			const onChunkUploadProgress = (uploadedChunkBytes) => {
+				uploadedBytes = uploadedBeforeThisPart + uploadedChunkBytes;
+				state.set(uploadId, { uploadedByteCount: uploadedBytes });
+				config.onProgress?.(uploadId, uploadedBytes);
+			};
+			const filePartResponse = await runAbortablePromise(() => promise_exports.retryPromise({
+				fn: () => uploadPartBytesWithProgress({
+					method,
+					url,
+					partBytes: chunk,
+					partIndex,
+					onProgress: onChunkUploadProgress,
+					abortSignal: abortController.signal
+				}),
+				retryCount: CONFIG.DEFAULT_RETRY_COUNT,
+				retryDelayMS: CONFIG.DEFAULT_RETRY_DELAY_MS
+			}));
+			completedPartIds[partIndex + 1] = filePartResponse.partId;
+			uploadedBytes = uploadedBeforeThisPart + bytes.length;
+			partIndex++;
+			state.set(uploadId, {
+				completedChunkCount: partIndex,
+				uploadedByteCount: uploadedBytes
+			});
+		};
+		await readStreamAndUpload(state, uploadId, stream, uploadPart, config);
+		if (state.isCancelled(uploadId) || state.isFailed(uploadId)) return;
+		state.setCompleted(uploadId, state.get(uploadId).completedChunkCount);
+		onFileUploadComplete?.({
+			uploadId,
+			filePartIds: completedPartIds
+		});
+	};
+	const uploadStreams = (streams) => {
+		const result = [];
+		for (const { uploadId, stream } of streams) result.push(uploadStreamFromPartIndex(uploadId, stream));
+		return Promise.allSettled(result).then(() => state.flush());
+	};
+	return {
+		uploadStreams,
+		getUploadState: state.get,
+		isFailed: state.isFailed,
+		isCancelled: state.isCancelled,
+		cancel: state.cancel,
+		cancelAll: state.cancelAll,
+		setFailed: state.setFailed
+	};
+};
+//#endregion
+//#region src/dataTransfer/upload/core/uploadManager/types.ts
+var UploadStates = {
+	IDLE: "idle",
+	IN_PROGRESS: "inprogress",
+	CANCELLED: "cancelled",
+	FAILED: "failed",
+	COMPLETE: "complete"
+};
+//#endregion
+//#region src/dataTransfer/upload/core/uploadClient/uploadClient.ts
+/**
+* Creates the raw upload lifecycle client:
+*
+* (1) - prepare a batch of items for upload
+* (2) - resolve a presigned URL for a given file part
+* (3) - complete an upload once all its parts are uploaded, or cancel one in progress.
+*/
+var createUploadClient = (options = {}) => {
+	const $ofetch = createHttpClient(options.customFetchClientOptions);
+	const prepareUpload = (parentId, items) => {
+		const fileByName = new Map(items.map(({ path: name, file }) => [name, file]));
+		const body = { items: Object.fromEntries(items.map(({ path: name, file }) => [name, {
+			itemContentType: getFileMimeType(file),
+			itemContentSize: file.size
+		}])) };
+		return $ofetch(`/repository/${parentId}/manifest`, {
+			method: "POST",
+			body
+		}).then(({ items: responseItems }) => Object.keys(responseItems).map((name) => ({
+			uploadId: responseItems[name].uploadId,
+			file: fileByName.get(name),
+			path: name
+		})));
+	};
+	const resolveFilePartUploadURL = (uploadId, partNumber) => {
+		return $ofetch(`/uploads/${uploadId}/parts/?partNumber=${partNumber}`, { method: "POST" });
+	};
+	const completeUpload = (uploadId, partIds) => {
+		return $ofetch(`/uploads/${uploadId}`, {
+			method: "POST",
+			body: partIds
+		});
+	};
+	const cancelUpload = (uploadId) => {
+		return $ofetch(`/uploads/${uploadId}`, { method: "DELETE" });
+	};
+	const getUploadStatus = (uploadIds) => {
+		return $ofetch("/uploads/status", {
+			method: "GET",
+			query: { uploadIds: uploadIds.join(",") }
+		});
+	};
+	return {
+		prepareUpload,
+		resolveFilePartUploadURL,
+		completeUpload,
+		cancelUpload,
+		getUploadStatus
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/es-toolkit@1.49.0/node_modules/es-toolkit/dist/array/chunk.mjs
+/**
+* Splits an array into smaller arrays of a specified length.
+*
+* This function takes an input array and divides it into multiple smaller arrays,
+* each of a specified length. If the input array cannot be evenly divided,
+* the final sub-array will contain the remaining elements.
+*
+* @template T The type of elements in the array.
+* @param arr - The array to be chunked into smaller arrays.
+* @param size - The size of each smaller array. Must be a positive integer.
+* @returns A two-dimensional array where each sub-array has a maximum length of `size`.
+* @throws {Error} Throws an error if `size` is not a positive integer.
+*
+* @example
+* // Splits an array of numbers into sub-arrays of length 2
+* chunk([1, 2, 3, 4, 5], 2);
+* // Returns: [[1, 2], [3, 4], [5]]
+*
+* @example
+* // Splits an array of strings into sub-arrays of length 3
+* chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+* // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+*/
+function chunk(arr, size) {
+	if (!Number.isInteger(size) || size <= 0) throw new Error("Size must be an integer greater than zero.");
+	const chunkLength = Math.ceil(arr.length / size);
+	const result = Array(chunkLength);
+	for (let index = 0; index < chunkLength; index++) {
+		const start = index * size;
+		const end = start + size;
+		result[index] = arr.slice(start, end);
+	}
+	return result;
+}
+//#endregion
+//#region src/dataTransfer/upload/core/uploadClient/createUploadStatusPoller.ts
+var DEFAULT_POLL_INTERVAL_MS = 1500;
+var DEFAULT_POLL_TIMEOUT = 300 * 1e3;
+var MAX_IDS_PER_REQUEST = 100;
+var logger = () => consola.withTag("Upload status poller");
+function createUploadStatusPoller(uploadClient, options) {
+	const pending = /* @__PURE__ */ new Set();
+	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const pollTimeout = options.pollTimeout ?? DEFAULT_POLL_TIMEOUT;
+	let inFlight = null;
+	const poll = () => {
+		if (inFlight) return inFlight;
+		inFlight = (async () => {
+			const deadline = Date.now() + pollTimeout;
+			while (pending.size > 0 && Date.now() < deadline) try {
+				const promises = chunk([...pending.values()], MAX_IDS_PER_REQUEST).map((batch) => uploadClient.getUploadStatus(batch));
+				const statuses = (await Promise.all(promises)).flat();
+				for (const { uploadId, status, statusMessage } of statuses) if (status === "COMPLETED") {
+					pending.delete(uploadId);
+					options.onComplete(uploadId);
+				} else if (status === "FAILED" || status === "ABORTED") {
+					pending.delete(uploadId);
+					options.onFail(uploadId, statusMessage);
+				}
+				if (pending.size === 0) break;
+				await sleep(pollIntervalMs);
+			} catch (error) {
+				logger().error("Failed while polling for upload batch status", { error });
+				await sleep(pollIntervalMs);
+				continue;
+			}
+			for (const uploadId of pending) {
+				pending.delete(uploadId);
+				options.onFail(uploadId, "Timed out waiting for processing to complete");
+			}
+		})().finally(() => {
+			inFlight = null;
+		});
+		return inFlight;
+	};
+	return {
+		/**
+		* Tracks an id for polling. Will start the polling requests immediately unless indicated otherwise
+		* by the `startPolling` parameter.
+		*
+		* Adding newer ids to an already-running poller is not a problem, since new ids just
+		* increase the poll batch size upon the next execution of the polling request
+		*
+		* @param uploadId
+		* @param startPolling
+		*/
+		track: (uploadId, startPolling = true) => {
+			pending.add(uploadId);
+			if (startPolling) return poll();
+			return Promise.resolve();
+		},
+		stop: () => pending.clear()
+	};
+}
+//#endregion
+export { createUploadManager as a, API_BASE_URL as c, createStreamingUploadManager as i, createUploadClient as n, createHttpClient as o, UploadStates as r, defaultConfig as s, createUploadStatusPoller as t };
+
+//# sourceMappingURL=core-CVWznjtP.js.map