nec-oss 0.1.0

package/dist/nec-oss.iife.js

@@ -0,0 +1,812 @@
+var NecOss = (function(exports) {
+
+
+//#region ../core/dist/index.js
+	var EventEmitter = class {
+		listeners = /* @__PURE__ */ new Map();
+		emit(eventName, payload) {
+			(this.listeners.get(eventName) ?? /* @__PURE__ */ new Set()).forEach((handler) => {
+				handler(payload);
+			});
+		}
+		on(eventName, handler) {
+			const handlers = this.listeners.get(eventName) ?? /* @__PURE__ */ new Set();
+			handlers.add(handler);
+			this.listeners.set(eventName, handlers);
+			return () => {
+				handlers.delete(handler);
+			};
+		}
+	};
+	let nextId = 0;
+	function createUploadFile(file) {
+		const name = getFileName(file);
+		const type = "type" in file ? file.type : "";
+		const size = "size" in file ? file.size : 0;
+		nextId += 1;
+		return {
+			id: `upload-${Date.now()}-${nextId}`,
+			file,
+			name,
+			progress: {
+				percent: 0,
+				loaded: 0,
+				total: size
+			},
+			size,
+			status: "pending",
+			type
+		};
+	}
+	function normalizeFiles(files) {
+		if (isFileList(files)) return Array.from(files);
+		if (Array.isArray(files)) return files;
+		return [files];
+	}
+	function isFileList(files) {
+		return typeof FileList !== "undefined" && files instanceof FileList;
+	}
+	function getFileName(file) {
+		if ("name" in file && typeof file.name === "string") return file.name;
+		return "blob";
+	}
+	function validateFiles(files, existingFiles, options = {}) {
+		const acceptedFiles = [];
+		const invalidFiles = [];
+		return files.reduce((promise, file) => {
+			return promise.then(() => {
+				return validateFile(file, {
+					acceptedFiles,
+					existingFiles,
+					files
+				}, options).then((result) => {
+					if (result.valid) {
+						acceptedFiles.push(file);
+						return;
+					}
+					invalidFiles.push({
+						file: file.file,
+						name: file.name,
+						reason: result.message ?? "文件校验失败",
+						rule: result.rule ?? "custom"
+					});
+				});
+			});
+		}, Promise.resolve()).then(() => ({
+			acceptedFiles,
+			invalidFiles
+		}));
+	}
+	function validateFile(file, context, options) {
+		const builtInResult = validateBuiltInRules(file, context, options);
+		if (!builtInResult.valid) return Promise.resolve(builtInResult);
+		return (options.customValidators ?? []).reduce((promise, validator) => {
+			return promise.then((currentResult) => {
+				if (!currentResult.valid) return currentResult;
+				return Promise.resolve(validator(file, context)).then(normalizeValidationResult);
+			});
+		}, Promise.resolve({ valid: true }));
+	}
+	function validateBuiltInRules(file, context, options) {
+		if (options.allowEmpty !== true && file.size === 0) return {
+			valid: false,
+			message: "不允许上传空文件",
+			rule: "allowEmpty"
+		};
+		if (typeof options.maxCount === "number" && context.existingFiles.length + context.acceptedFiles.length >= options.maxCount) return {
+			valid: false,
+			message: `最多只能上传 ${options.maxCount} 个文件`,
+			rule: "maxCount"
+		};
+		if (typeof options.maxSize === "number" && file.size > options.maxSize) return {
+			valid: false,
+			message: `文件大小不能超过 ${options.maxSize} 字节`,
+			rule: "maxSize"
+		};
+		if (typeof options.minSize === "number" && file.size < options.minSize) return {
+			valid: false,
+			message: `文件大小不能小于 ${options.minSize} 字节`,
+			rule: "minSize"
+		};
+		if (options.allowDuplicateName !== true && hasDuplicateName(file, context)) return {
+			valid: false,
+			message: "不允许上传重名文件",
+			rule: "allowDuplicateName"
+		};
+		if (options.accept && !matchesAccept(file, options.accept)) return {
+			valid: false,
+			message: "文件类型不符合要求",
+			rule: "accept"
+		};
+		if (options.extensions && options.extensions.length > 0 && !matchesExtension(file, options.extensions)) return {
+			valid: false,
+			message: "文件扩展名不符合要求",
+			rule: "extensions"
+		};
+		return { valid: true };
+	}
+	function normalizeValidationResult(result) {
+		if (typeof result === "boolean") return { valid: result };
+		if (typeof result === "string") return {
+			message: result,
+			rule: "custom",
+			valid: false
+		};
+		return result;
+	}
+	function hasDuplicateName(file, context) {
+		return [...context.existingFiles, ...context.files].filter((item) => item.name === file.name).length > 1;
+	}
+	function matchesAccept(file, accept) {
+		return (Array.isArray(accept) ? accept : accept.split(",")).map((item) => item.trim()).filter(Boolean).some((item) => {
+			if (item.endsWith("/*")) return file.type.startsWith(item.slice(0, -1));
+			if (item.startsWith(".")) return file.name.toLowerCase().endsWith(item.toLowerCase());
+			return file.type === item;
+		});
+	}
+	function matchesExtension(file, extensions) {
+		const normalizedName = file.name.toLowerCase();
+		return extensions.some((extension) => {
+			const normalizedExtension = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+			return normalizedName.endsWith(normalizedExtension);
+		});
+	}
+	function createUploader(options) {
+		return new UploadQueue(options);
+	}
+	var UploadQueue = class {
+		emitter = new EventEmitter();
+		files = [];
+		taskMap = /* @__PURE__ */ new Map();
+		activeCount = 0;
+		runningPromise;
+		resolveRunning;
+		constructor(options) {
+			this.options = options;
+		}
+		add(inputFiles) {
+			return validateFiles(normalizeFiles(inputFiles).map(createUploadFile), this.files, this.options.validate).then((result) => {
+				result.acceptedFiles.forEach((file) => {
+					this.files.push(file);
+					this.taskMap.set(file.id, new UploadTaskImpl(file, this));
+				});
+				this.emitQueueChange();
+				return result;
+			});
+		}
+		start() {
+			if (this.runningPromise) return this.runningPromise;
+			this.runningPromise = new Promise((resolve) => {
+				this.resolveRunning = resolve;
+			}).finally(() => {
+				this.resolveRunning = void 0;
+				this.runningPromise = void 0;
+			});
+			this.runNext();
+			return this.runningPromise;
+		}
+		pauseAll() {
+			return this.getTasks().reduce((promise, task) => promise.then(() => task.pause()), Promise.resolve()).then(() => void 0);
+		}
+		resumeAll() {
+			this.files.filter((file) => file.status === "paused").forEach((file) => {
+				file.status = "pending";
+			});
+			this.emitQueueChange();
+			return this.start();
+		}
+		cancelAll() {
+			return this.getTasks().reduce((promise, task) => promise.then(() => task.cancel()), Promise.resolve()).then(() => void 0);
+		}
+		cancel(fileIds) {
+			return this.runByFileIds(fileIds, (task) => task.cancel());
+		}
+		pause(fileIds) {
+			return this.runByFileIds(fileIds, (task) => task.pause());
+		}
+		resume(fileIds) {
+			return this.runByFileIds(fileIds, (task) => task.resume());
+		}
+		retry(fileIds) {
+			return this.runByFileIds(fileIds, (task) => this.retryTask(task.file));
+		}
+		clear() {
+			if (!this.files.every((file) => file.status !== "uploading")) throw new Error("上传中不能清空队列");
+			this.files.splice(0, this.files.length);
+			this.taskMap.clear();
+			this.emitQueueChange();
+		}
+		getFiles() {
+			return [...this.files];
+		}
+		getTasks() {
+			return Array.from(this.taskMap.values());
+		}
+		on(eventName, handler) {
+			return this.emitter.on(eventName, handler);
+		}
+		runByFileIds(fileIds, runner) {
+			return normalizeFileIds(fileIds).reduce((promise, fileId) => {
+				return promise.then(() => {
+					const task = this.taskMap.get(fileId);
+					if (!task) throw new Error(`未找到文件任务：${fileId}`);
+					return runner(task);
+				});
+			}, Promise.resolve());
+		}
+		pauseTask(file) {
+			const task = this.taskMap.get(file.id);
+			if (!task || file.status !== "uploading") {
+				if (file.status === "pending") {
+					file.status = "paused";
+					this.emitQueueChange();
+				}
+				return Promise.resolve();
+			}
+			return Promise.resolve(this.options.provider.transformLifecycleRequest?.({}, {
+				file,
+				lifecycle: "pause"
+			}) ?? {}).then(() => this.getAdapter().pause?.({
+				file,
+				lifecycle: "pause",
+				prepared: task.prepared
+			})).then(() => {
+				task.abortController?.abort();
+				file.status = "paused";
+				this.emitQueueChange();
+			});
+		}
+		resumeTask(file) {
+			return Promise.resolve(this.options.provider.transformLifecycleRequest?.({}, {
+				file,
+				lifecycle: "resume"
+			}) ?? {}).then(() => this.getAdapter().resume?.({
+				file,
+				lifecycle: "resume",
+				prepared: this.taskMap.get(file.id)?.prepared
+			})).then(() => {
+				if (file.status === "paused") {
+					file.status = "pending";
+					this.emitQueueChange();
+				}
+				return this.start();
+			});
+		}
+		retryTask(file) {
+			if (file.status === "uploading") return Promise.resolve();
+			file.status = "pending";
+			file.error = void 0;
+			file.response = void 0;
+			file.rawResponse = void 0;
+			file.progress = {
+				loaded: 0,
+				percent: 0,
+				total: file.size
+			};
+			this.emitQueueChange();
+			return this.start();
+		}
+		cancelTask(file) {
+			const task = this.taskMap.get(file.id);
+			if (!task || file.status === "pending" || file.status === "paused") {
+				file.status = "canceled";
+				this.emitQueueChange();
+				return Promise.resolve();
+			}
+			return Promise.resolve(this.options.provider.transformLifecycleRequest?.({}, {
+				file,
+				lifecycle: "cancel"
+			}) ?? {}).then(() => this.getAdapter().cancel?.({
+				file,
+				lifecycle: "cancel",
+				prepared: task?.prepared
+			})).then(() => {
+				task?.abortController?.abort();
+				file.status = "canceled";
+				this.emitQueueChange();
+			});
+		}
+		runNext() {
+			const maxConcurrency = Math.max(1, this.options.maxConcurrency ?? 3);
+			while (this.activeCount < maxConcurrency) {
+				const nextFile = this.files.find((file) => file.status === "pending");
+				if (!nextFile) break;
+				this.activeCount += 1;
+				this.uploadFile(nextFile).finally(() => {
+					this.activeCount -= 1;
+					this.runNext();
+				});
+			}
+			if (this.activeCount === 0 && !this.files.some((file) => file.status === "pending")) {
+				this.emitter.emit("complete", { files: this.getFiles() });
+				this.resolveRunning?.();
+			}
+		}
+		uploadFile(file) {
+			const task = this.taskMap.get(file.id);
+			if (!task) return Promise.resolve();
+			file.status = "uploading";
+			task.abortController = new AbortController();
+			this.emitQueueChange();
+			return Promise.resolve(this.options.provider.prepare(file)).then((prepared) => {
+				task.prepared = prepared;
+				return this.getAdapter().upload({
+					file,
+					onProgress: (progress) => this.handleProgress(file, progress),
+					prepared,
+					signal: task.abortController?.signal ?? new AbortController().signal
+				});
+			}).then((result) => this.handleSuccess(file, result, task.prepared)).catch((error) => this.handleError(file, error));
+		}
+		handleProgress(file, progress) {
+			file.progress = progress;
+			file.checkpoint = progress.checkpoint;
+			this.emitter.emit("progress", {
+				file,
+				progress
+			});
+		}
+		handleSuccess(file, result, prepared) {
+			const key = result.key ?? prepared?.params.key ?? file.name;
+			const context = {
+				file,
+				lifecycle: "upload",
+				params: prepared?.params
+			};
+			return Promise.resolve(this.options.provider.response?.(result.rawResponse, context) ?? result.rawResponse).then((response) => {
+				file.status = "success";
+				file.rawResponse = result.rawResponse;
+				file.response = response;
+				file.checkpoint = result.checkpoint;
+				const payload = {
+					checkpoint: result.checkpoint,
+					key,
+					rawResponse: result.rawResponse,
+					response,
+					url: result.url
+				};
+				this.emitter.emit("success", {
+					file,
+					result: payload
+				});
+				this.emitQueueChange();
+			});
+		}
+		handleError(file, error) {
+			if (file.status === "paused" || file.status === "canceled") return;
+			const uploadError = {
+				checkpoint: file.checkpoint,
+				code: getErrorCode(error),
+				message: getErrorMessage(error),
+				raw: error
+			};
+			file.status = "error";
+			file.error = uploadError;
+			this.emitter.emit("error", {
+				error: uploadError,
+				file
+			});
+			this.emitQueueChange();
+		}
+		emitQueueChange() {
+			this.emitter.emit("change", { files: this.getFiles() });
+		}
+		getAdapter() {
+			const adapter = this.options.adapter ?? this.options.provider.adapter;
+			if (!adapter) throw new Error("上传缺少 adapter，请通过 provider 内置 adapter 或显式传入 adapter");
+			return adapter;
+		}
+	};
+	var UploadTaskImpl = class {
+		abortController;
+		prepared;
+		constructor(file, queue) {
+			this.file = file;
+			this.queue = queue;
+		}
+		cancel() {
+			return this.queue.cancelTask(this.file);
+		}
+		on(eventName, handler) {
+			return this.queue.on(eventName, handler);
+		}
+		pause() {
+			return this.queue.pauseTask(this.file);
+		}
+		resume() {
+			return this.queue.resumeTask(this.file);
+		}
+	};
+	function getErrorCode(error) {
+		if (error && typeof error === "object" && "code" in error && typeof error.code === "string") return error.code;
+		return "UPLOAD_ERROR";
+	}
+	function getErrorMessage(error) {
+		if (error instanceof Error) return error.message;
+		if (error && typeof error === "object" && "message" in error && typeof error.message === "string") return error.message;
+		return "文件上传失败";
+	}
+	function normalizeFileIds(fileIds) {
+		return Array.isArray(fileIds) ? fileIds : [fileIds];
+	}
+
+//#endregion
+//#region src/oss/runtime.ts
+	const DEFAULT_OSS_STS_URL = "/education/serverApi/oss-sts/token";
+	function loadOssSdk(options) {
+		return Promise.resolve(options.loadSdk?.() ?? import("ali-oss").then((module) => module.default));
+	}
+	function buildOssClientOptions(options, token, refreshSTSToken) {
+		const runtimeConfig = resolveRuntimeConfig(options, token);
+		return {
+			accessKeyId: token.accessKeyId,
+			accessKeySecret: token.accessKeySecret,
+			authorizationV4: options.authorizationV4 ?? true,
+			bucket: runtimeConfig.bucket,
+			cname: runtimeConfig.cname,
+			endpoint: runtimeConfig.endpoint,
+			region: runtimeConfig.region,
+			...refreshSTSToken ? { refreshSTSToken } : {},
+			secure: runtimeConfig.secure,
+			stsToken: token.stsToken,
+			timeout: options.timeout
+		};
+	}
+	function resolveRuntimeConfig(options, token) {
+		const bucket = options.bucket ?? token.bucket;
+		const endpoint = options.endpoint ?? token.endpoint;
+		const region = options.region ?? token.region ?? getRegionFromEndpoint(endpoint);
+		if (!bucket || !region) throw new Error("OSS 缺少 bucket 或 endpoint/region，请确认 STS 响应或 OSS 配置");
+		return {
+			bucket,
+			cname: options.cname ?? token.cname,
+			endpoint,
+			region,
+			secure: options.secure ?? token.secure
+		};
+	}
+	function requestAndTransformStsToken(context, options) {
+		const request = {
+			headers: {},
+			method: "GET",
+			query: {},
+			url: options.stsUrl ?? DEFAULT_OSS_STS_URL
+		};
+		return Promise.resolve(options.beforeStsTokenReq?.(request, context) ?? request).then((nextRequest) => requestStsToken(nextRequest, context, options)).then((stsResponse) => {
+			return Promise.resolve(options.beforeStsTokenRes?.(stsResponse, context) ?? defaultTransformStsResponse(stsResponse));
+		});
+	}
+	function createRefreshStsToken(context, options) {
+		if (!options.refreshStsToken && !options.refreshStsUrl) return;
+		if (options.refreshStsToken) {
+			const refreshStsToken = options.refreshStsToken;
+			return () => refreshStsToken(context);
+		}
+		return () => requestAndTransformRefreshStsToken(context, options);
+	}
+	function getOssRuntimeConfig(token) {
+		const region = token.region ?? getRegionFromEndpoint(token.endpoint);
+		if (!token.bucket || !region) throw new Error("STS 响应缺少 bucket 或 endpoint/region");
+		return {
+			bucket: token.bucket,
+			cname: token.cname,
+			endpoint: token.endpoint,
+			region,
+			secure: token.secure
+		};
+	}
+	function requestStsToken(request, context, options) {
+		return Promise.resolve(options.requestStsToken?.(request, context) ?? sendRequest(request));
+	}
+	function requestAndTransformRefreshStsToken(context, options) {
+		const request = {
+			headers: {},
+			method: "GET",
+			query: {},
+			url: options.refreshStsUrl
+		};
+		return Promise.resolve(options.beforeRefreshStsTokenReq?.(request, context) ?? request).then((nextRequest) => requestRefreshStsToken(nextRequest, context, options)).then((refreshResponse) => {
+			return Promise.resolve(options.beforeRefreshStsTokenRes?.(refreshResponse, context) ?? defaultTransformRefreshStsResponse(refreshResponse));
+		});
+	}
+	function requestRefreshStsToken(request, context, options) {
+		return Promise.resolve(options.requestRefreshStsToken?.(request, context) ?? sendRequest(request));
+	}
+	function sendRequest(request) {
+		if (!request.url) return Promise.reject(/* @__PURE__ */ new Error("STS 请求地址不能为空"));
+		const method = request.method ?? "GET";
+		const headers = request.headers ?? {};
+		const url = buildUrl(request.url, request.query);
+		const init = {
+			headers,
+			method
+		};
+		if (method.toUpperCase() !== "GET" && typeof request.body !== "undefined") {
+			init.body = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
+			init.headers = {
+				"Content-Type": "application/json",
+				...headers
+			};
+		}
+		return fetch(url, init).then((response) => {
+			if (!response.ok) throw new Error(`STS 请求失败：${response.status}`);
+			return response.json();
+		});
+	}
+	function defaultTransformRefreshStsResponse(response) {
+		const token = defaultTransformStsResponse(response);
+		return {
+			accessKeyId: token.accessKeyId,
+			accessKeySecret: token.accessKeySecret,
+			stsToken: token.stsToken
+		};
+	}
+	function defaultTransformStsResponse(response) {
+		const candidates = [
+			response,
+			getObjectValue(response, "data"),
+			getObjectValue(getObjectValue(response, "data"), "credentials"),
+			getObjectValue(response, "credentials")
+		];
+		for (const candidate of candidates) {
+			if (!isRecord(candidate)) continue;
+			const accessKeyId = getStringValue(candidate, ["accessKeyId", "AccessKeyId"]);
+			const accessKeySecret = getStringValue(candidate, ["accessKeySecret", "AccessKeySecret"]);
+			const stsToken = getStringValue(candidate, [
+				"stsToken",
+				"securityToken",
+				"SecurityToken"
+			]);
+			const expiration = getStringValue(candidate, ["expiration", "Expiration"]);
+			const bucket = getStringValue(candidate, [
+				"bucket",
+				"bucketName",
+				"Bucket",
+				"BucketName"
+			]);
+			const endpoint = getStringValue(candidate, ["endpoint", "Endpoint"]);
+			const region = getStringValue(candidate, ["region", "Region"]) ?? getRegionFromEndpoint(endpoint);
+			const uploadPrefix = getStringValue(candidate, [
+				"uploadPrefix",
+				"prefix",
+				"Prefix"
+			]);
+			if (accessKeyId && accessKeySecret && stsToken) return {
+				accessKeyId,
+				accessKeySecret,
+				bucket,
+				endpoint,
+				expiration,
+				region,
+				stsToken,
+				uploadPrefix
+			};
+		}
+		throw new Error("STS 响应缺少 accessKeyId/accessKeySecret/stsToken，请配置 beforeStsTokenRes");
+	}
+	function getRegionFromEndpoint(endpoint) {
+		if (!endpoint) return;
+		return getEndpointHostname(endpoint).match(/^(?:[^.]+--)?(oss-[a-z0-9-]+)\./)?.[1];
+	}
+	function getEndpointHostname(endpoint) {
+		try {
+			return new URL(endpoint).hostname;
+		} catch {
+			return endpoint.replace(/^https?:\/\//, "").split("/")[0] ?? endpoint;
+		}
+	}
+	function buildUrl(url, query = {}) {
+		const baseUrl = typeof window !== "undefined" && window.location?.origin ? window.location.origin : "http://localhost";
+		const targetUrl = new URL(url, baseUrl);
+		Object.entries(query).forEach(([key, value]) => {
+			if (typeof value === "undefined" || value === null) return;
+			targetUrl.searchParams.set(key, String(value));
+		});
+		return targetUrl.toString();
+	}
+	function getObjectValue(source, key) {
+		if (!isRecord(source)) return;
+		return source[key];
+	}
+	function getStringValue(source, keys) {
+		for (const key of keys) {
+			const value = source[key];
+			if (typeof value === "string" || typeof value === "number") return String(value);
+		}
+	}
+	function isRecord(value) {
+		return typeof value === "object" && value !== null;
+	}
+
+//#endregion
+//#region src/oss/adapter.ts
+	function createOssAdapter(options) {
+		const runtime = /* @__PURE__ */ new Map();
+		return {
+			name: "oss",
+			cancel(context) {
+				return cancelUpload(context, runtime);
+			},
+			pause(context) {
+				runtime.get(context.file.id)?.cancel?.();
+				return Promise.resolve();
+			},
+			resume() {
+				return Promise.resolve();
+			},
+			upload(context) {
+				const token = context.prepared.token;
+				if (!token) return Promise.reject(/* @__PURE__ */ new Error("OSS 上传缺少 STS Token"));
+				return loadOssSdk(options).then((OssClient) => {
+					const client = new OssClient(buildOssClientOptions(options, token, getRefreshStsToken(context)));
+					const runtimeItem = {
+						checkpoint: context.file.checkpoint,
+						client
+					};
+					runtime.set(context.file.id, runtimeItem);
+					return runMultipartUpload(context, options, runtimeItem).finally(() => {
+						runtime.delete(context.file.id);
+					});
+				});
+			}
+		};
+	}
+	function getRefreshStsToken(context) {
+		const refreshSTSToken = context.prepared.extra?.refreshSTSToken;
+		return typeof refreshSTSToken === "function" ? refreshSTSToken : void 0;
+	}
+	function runMultipartUpload(context, options, runtime) {
+		const params = context.prepared.params;
+		const uploadOptions = {
+			callback: params.callback,
+			checkpoint: runtime.checkpoint,
+			headers: params.headers,
+			meta: params.meta,
+			mime: params.mime,
+			parallel: params.parallel ?? options.parallel,
+			partSize: params.partSize ?? options.partSize,
+			progress(progress, checkpoint, raw) {
+				runtime.checkpoint = checkpoint;
+				context.onProgress({
+					checkpoint,
+					loaded: Math.round((context.file.size || 0) * progress),
+					percent: Math.round(progress * 1e4) / 100,
+					raw,
+					total: context.file.size
+				});
+			}
+		};
+		if (typeof AbortController !== "undefined") context.signal.addEventListener("abort", () => {
+			runtime.cancel?.();
+		});
+		const uploadPromise = runtime.client.multipartUpload(params.key, params.file, uploadOptions);
+		if (uploadPromise && typeof uploadPromise === "object" && "cancel" in uploadPromise) runtime.cancel = () => {
+			const cancel = uploadPromise.cancel;
+			if (typeof cancel === "function") cancel.call(uploadPromise);
+		};
+		return Promise.resolve(uploadPromise).then((rawResponse) => ({
+			checkpoint: runtime.checkpoint,
+			key: params.key,
+			rawResponse,
+			url: getResponseUrl(rawResponse)
+		}));
+	}
+	function cancelUpload(context, runtime) {
+		const runtimeItem = runtime.get(context.file.id);
+		const checkpoint = runtimeItem?.checkpoint ?? context.file.checkpoint;
+		runtimeItem?.cancel?.();
+		if (!runtimeItem?.client || !checkpoint?.name || !checkpoint.uploadId) return Promise.resolve();
+		return Promise.resolve(runtimeItem.client.abortMultipartUpload(checkpoint.name, checkpoint.uploadId)).then(() => void 0);
+	}
+	function getResponseUrl(response) {
+		if (response && typeof response === "object" && "url" in response && typeof response.url === "string") return response.url;
+		if (response && typeof response === "object" && "res" in response && response.res && typeof response.res === "object" && "requestUrls" in response.res && Array.isArray(response.res.requestUrls)) return response.res.requestUrls[0];
+	}
+
+//#endregion
+//#region src/oss/provider.ts
+	function createOssProvider(options = {}) {
+		return {
+			adapter: createOssAdapter(options),
+			name: "oss",
+			prepare(file) {
+				return requestAndTransformStsToken({
+					file,
+					lifecycle: "sts"
+				}, options).then((token) => buildUploadParams(file, token, options));
+			},
+			transformLifecycleRequest(request, context) {
+				return Promise.resolve(options.transformLifecycleRequest?.(request, context) ?? request);
+			},
+			response(response, context) {
+				return Promise.resolve(options.response?.(response, context) ?? response);
+			}
+		};
+	}
+	function buildUploadParams(file, token, options) {
+		const context = {
+			file,
+			lifecycle: "upload",
+			token
+		};
+		return Promise.resolve(options.keyResolver?.(file, context) ?? defaultKeyResolver(file, token, options)).then((key) => {
+			const refreshSTSToken = createRefreshStsToken({
+				file,
+				lifecycle: "sts"
+			}, options);
+			const params = {
+				callback: options.callback,
+				extra: {
+					...options.extra ?? {},
+					...refreshSTSToken ? { refreshSTSToken } : {},
+					token
+				},
+				file: file.file,
+				headers: {},
+				key,
+				meta: {},
+				mime: options.mime ?? file.type,
+				parallel: options.parallel,
+				partSize: options.partSize
+			};
+			const uploadContext = {
+				file,
+				lifecycle: "upload",
+				params,
+				token
+			};
+			return Promise.resolve(options.beforeUploadReq?.(params, uploadContext) ?? params).then((nextParams) => ({
+				extra: {
+					...refreshSTSToken ? { refreshSTSToken } : {},
+					token
+				},
+				params: nextParams,
+				token
+			}));
+		});
+	}
+	function defaultKeyResolver(file, token, options) {
+		const safeName = file.name.replace(/^\.+/, "").replace(/[^\w.\\/=-]+/g, "-");
+		return `${options.uploadPrefix ? normalizePrefix(options.uploadPrefix) : token.uploadPrefix ? normalizePrefix(token.uploadPrefix) : "uploads/"}${Date.now()}-${safeName}`;
+	}
+	function normalizePrefix(prefix) {
+		if (!prefix) return "";
+		return prefix.endsWith("/") ? prefix : `${prefix}/`;
+	}
+
+//#endregion
+//#region src/oss/client.ts
+	function createOssClient(options = {}) {
+		const context = { lifecycle: "sts" };
+		return requestAndTransformStsToken(context, options).then((token) => {
+			const refreshSTSToken = createRefreshStsToken(context, options);
+			return loadOssSdk(options).then((OssClient) => {
+				return new OssClient(buildOssClientOptions(options, token, refreshSTSToken));
+			});
+		});
+	}
+
+//#endregion
+//#region src/uploader.ts
+	let defaultOssProviderOptions = {};
+	function createOssUploader(options = {}) {
+		return createUploader({
+			...options,
+			provider: options.provider ?? createOssProvider(defaultOssProviderOptions)
+		});
+	}
+	function setDefaultOssProviderOptions(options) {
+		defaultOssProviderOptions = options;
+	}
+
+//#endregion
+exports.DEFAULT_OSS_STS_URL = DEFAULT_OSS_STS_URL;
+exports.createOssAdapter = createOssAdapter;
+exports.createOssClient = createOssClient;
+exports.createOssProvider = createOssProvider;
+exports.createOssUploader = createOssUploader;
+exports.getOssRuntimeConfig = getOssRuntimeConfig;
+exports.setDefaultOssProviderOptions = setDefaultOssProviderOptions;
+return exports;
+})({});
+//# sourceMappingURL=nec-oss.iife.js.map