nec-oss 0.1.0

package/dist/index.js

@@ -0,0 +1,801 @@
+//#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
+export { DEFAULT_OSS_STS_URL, createOssAdapter, createOssClient, createOssProvider, createOssUploader, getOssRuntimeConfig, setDefaultOssProviderOptions };
+//# sourceMappingURL=index.js.map