@cloudbase/storage 3.1.1 → 3.1.2

package/dist/esm/index.js

@@ -1,5 +1,716 @@
-import { CloudbaseStorage, COMPONENT_NAME } from './storage';
-import { SupabaseFileAPILikeStorage } from './supabase';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { isStorageError, StorageError } from './supabase/errors';
+import { constants, utils, helpers } from '@cloudbase/utilities';
+var EUploadMethod;
+(function (EUploadMethod) {
+    EUploadMethod["put"] = "put";
+    EUploadMethod["post"] = "post";
+})(EUploadMethod || (EUploadMethod = {}));
+var getSdkName = constants.getSdkName, ERRORS = constants.ERRORS, COMMUNITY_SITE_URL = constants.COMMUNITY_SITE_URL;
+var isArray = utils.isArray, isString = utils.isString, isPalinObject = utils.isPalinObject, execCallback = utils.execCallback;
+var catchErrorsDecorator = helpers.catchErrorsDecorator;
+export var COMPONENT_NAME = 'storage';
+var storageGateWay = {
+    getUploadInfo: function (request, params, customReqOpts) { return __awaiter(void 0, void 0, void 0, function () {
+        var res, data;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4, request.gateWay({
+                        path: 'storages',
+                        name: 'get-objects-upload-info',
+                        data: [
+                            __assign({ objectId: params.path }, (params.headers ? { signedHeader: params.headers } : {})),
+                        ],
+                    }, customReqOpts)];
+                case 1:
+                    res = _b.sent();
+                    data = ((_a = res.data) === null || _a === void 0 ? void 0 : _a[0]) || {};
+                    res = __assign(__assign({}, res), { data: __assign(__assign({}, (data.code ? __assign({}, data) : {})), { authorization: data.authorization, token: data.token, url: data.uploadUrl, fileId: data.cloudObjectId, cosFileId: data.cloudObjectMeta, download_url: data.downloadUrl }) });
+                    return [2, res];
+            }
+        });
+    }); },
+    getDownLoadInfo: function (request, params, customReqOpts) { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4, request.gateWay({
+                        path: 'storages',
+                        name: 'get-objects-download-info',
+                        data: params.convertedFileList.map(function (v) { return ({ cloudObjectId: v.fileid }); }),
+                    }, customReqOpts)];
+                case 1:
+                    res = _b.sent();
+                    res = __assign(__assign({}, res), { data: {
+                            download_list: (_a = res.data) === null || _a === void 0 ? void 0 : _a.map(function (v) { return ({
+                                code: v.code || 'SUCCESS',
+                                message: v.message,
+                                fileid: v.cloudObjectId,
+                                download_url: v.downloadUrl,
+                                fileID: v.cloudObjectId,
+                                tempFileURL: v.downloadUrl,
+                            }); }),
+                        } });
+                    return [2, res];
+            }
+        });
+    }); },
+    delete: function (request, params, customReqOpts) { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4, request.gateWay({
+                        path: 'storages',
+                        name: 'delete-objects',
+                        data: params.fileList.map(function (v) { return ({ cloudObjectId: v }); }),
+                    }, customReqOpts)];
+                case 1:
+                    res = _b.sent();
+                    res = __assign(__assign({}, res), { data: {
+                            delete_list: (_a = res.data) === null || _a === void 0 ? void 0 : _a.map(function (v) { return ({
+                                code: v.code || 'SUCCESS',
+                                fileID: v.cloudObjectId,
+                                message: v.message,
+                            }); }),
+                        } });
+                    return [2, res];
+            }
+        });
+    }); },
+    copyFile: function (request, params, customReqOpts) { return __awaiter(void 0, void 0, void 0, function () {
+        var res;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4, request.gateWay({
+                        path: 'storages',
+                        name: 'copy-objects',
+                        data: params.convertedFileList.map(function (v) { return ({
+                            srcPath: v.src_path,
+                            dstPath: v.dst_path,
+                            overwrite: v.overwrite,
+                            removeOriginal: v.remove_original,
+                        }); }),
+                    }, customReqOpts)];
+                case 1:
+                    res = _b.sent();
+                    res = __assign(__assign({}, res), { data: {
+                            copy_list: (_a = res.data) === null || _a === void 0 ? void 0 : _a.map(function (v) { return ({
+                                code: v.code || 'SUCCESS',
+                                fileID: v.cloudObjectId,
+                                message: v.message,
+                            }); }),
+                        } });
+                    return [2, res];
+            }
+        });
+    }); },
+};
+export var CloudbaseStorage = (function () {
+    function CloudbaseStorage() {
+    }
+    CloudbaseStorage.prototype.isGateWay = function () {
+        var config = this.config;
+        var endPointMode = config.endPointMode || 'CLOUD_API';
+        return endPointMode === 'GATEWAY';
+    };
+    CloudbaseStorage.prototype.uploadFile = function (params, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cloudPath, filePath, onUploadProgress, method, headers, fileContent, uploadMethod, metadataResult, metadata, requestId, url, authorization, token, fileId, cosFileId, downloadUrl, commonParams, putParams, postParams, uploadConfig, res;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        cloudPath = params.cloudPath, filePath = params.filePath, onUploadProgress = params.onUploadProgress, method = (_a = params.method, _a === void 0 ? 'put' : _a), headers = (_b = params.headers, _b === void 0 ? {} : _b), fileContent = params.fileContent;
+                        if (!isString(cloudPath) || (!filePath && !fileContent)) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "[".concat(COMPONENT_NAME, ".uploadFile] invalid params"),
+                            }));
+                        }
+                        uploadMethod = { put: EUploadMethod.put, post: EUploadMethod.post }[method.toLocaleLowerCase()] || EUploadMethod.put;
+                        return [4, this.getUploadMetadata({
+                                cloudPath: cloudPath,
+                                method: uploadMethod,
+                                headers: uploadMethod === EUploadMethod.put ? headers : undefined,
+                                customReqOpts: params.customReqOpts,
+                            })];
+                    case 1:
+                        metadataResult = _d.sent();
+                        metadata = metadataResult.data, requestId = metadataResult.requestId;
+                        url = metadata.url, authorization = metadata.authorization, token = metadata.token, fileId = metadata.fileId, cosFileId = metadata.cosFileId, downloadUrl = metadata.download_url;
+                        commonParams = {
+                            url: url,
+                            file: filePath,
+                            name: cloudPath,
+                            onUploadProgress: onUploadProgress,
+                            fileContent: fileContent,
+                            fileId: fileId,
+                            requestId: requestId,
+                        };
+                        putParams = __assign(__assign({}, commonParams), { method: EUploadMethod.put, headers: __assign(__assign({}, headers), { authorization: authorization, 'x-cos-meta-fileid': cosFileId, 'x-cos-security-token': token }) });
+                        postParams = __assign(__assign({}, commonParams), { method: EUploadMethod.post, data: {
+                                key: cloudPath,
+                                signature: authorization,
+                                'x-cos-meta-fileid': cosFileId,
+                                success_action_status: '201',
+                                'x-cos-security-token': token,
+                            } });
+                        uploadConfig = (_c = {},
+                            _c[EUploadMethod.put] = {
+                                params: putParams,
+                                isSuccess: function (code) { return code >= 200 && code < 300; },
+                            },
+                            _c[EUploadMethod.post] = {
+                                params: postParams,
+                                isSuccess: function (code) { return code === 201; },
+                            },
+                            _c);
+                        return [4, this.request.upload(uploadConfig[uploadMethod].params)];
+                    case 2:
+                        res = _d.sent();
+                        if (uploadConfig[uploadMethod].isSuccess(res.statusCode)) {
+                            return [2, execCallback(callback, null, {
+                                    fileID: fileId,
+                                    download_url: downloadUrl,
+                                    requestId: requestId,
+                                })];
+                        }
+                        return [2, execCallback(callback, new Error("[".concat(getSdkName(), "][").concat(ERRORS.OPERATION_FAIL, "][").concat(COMPONENT_NAME, "]:").concat(res.data)))];
+                }
+            });
+        });
+    };
+    CloudbaseStorage.prototype.getUploadMetadata = function (params, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cloudPath, method, headers, request, action, metaData, metaDataParam, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        cloudPath = params.cloudPath, method = params.method, headers = params.headers;
+                        if (!isString(cloudPath)) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "[".concat(COMPONENT_NAME, ".getUploadMetadata] invalid cloudPath"),
+                            }));
+                        }
+                        request = this.request;
+                        action = 'storage.getUploadMetadata';
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        metaData = void 0;
+                        metaDataParam = { path: cloudPath };
+                        if (method) {
+                            metaDataParam.method = method;
+                        }
+                        if (method === EUploadMethod.put && headers) {
+                            metaDataParam.headers = headers;
+                        }
+                        if (!this.isGateWay()) return [3, 3];
+                        return [4, storageGateWay.getUploadInfo(request, metaDataParam, params.customReqOpts)];
+                    case 2:
+                        metaData = _a.sent();
+                        return [3, 5];
+                    case 3: return [4, request.send(action, metaDataParam, params.customReqOpts)];
+                    case 4:
+                        metaData = _a.sent();
+                        _a.label = 5;
+                    case 5: return [2, execCallback(callback, null, metaData)];
+                    case 6:
+                        err_1 = _a.sent();
+                        return [2, execCallback(callback, err_1)];
+                    case 7: return [2];
+                }
+            });
+        });
+    };
+    CloudbaseStorage.prototype.deleteFile = function (params, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileList, _i, fileList_1, fileId, action, request, res, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fileList = params.fileList;
+                        if (!fileList || !isArray(fileList) || fileList.length === 0) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "[".concat(COMPONENT_NAME, ".deleteFile] fileList must not be empty"),
+                            }));
+                        }
+                        for (_i = 0, fileList_1 = fileList; _i < fileList_1.length; _i++) {
+                            fileId = fileList_1[_i];
+                            if (!fileId || !isString(fileId)) {
+                                throw new Error(JSON.stringify({
+                                    code: ERRORS.INVALID_PARAMS,
+                                    msg: "[".concat(COMPONENT_NAME, ".deleteFile] fileID must be string"),
+                                }));
+                            }
+                        }
+                        action = 'storage.batchDeleteFile';
+                        request = this.request;
+                        res = {};
+                        if (!this.isGateWay()) return [3, 2];
+                        return [4, storageGateWay.delete(request, { fileList: fileList }, params.customReqOpts)];
+                    case 1:
+                        res = _a.sent();
+                        return [3, 4];
+                    case 2: return [4, request.send(action, {
+                            fileid_list: fileList,
+                        }, params.customReqOpts)];
+                    case 3:
+                        res = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (res.code) {
+                            return [2, execCallback(callback, null, res)];
+                        }
+                        data = {
+                            fileList: res.data.delete_list,
+                            requestId: res.requestId,
+                        };
+                        return [2, execCallback(callback, null, data)];
+                }
+            });
+        });
+    };
+    CloudbaseStorage.prototype.getTempFileURL = function (params, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileList, convertedFileList, _i, fileList_2, file, action, request, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fileList = params.fileList;
+                        if (!fileList || !isArray(fileList) || fileList.length === 0) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "[".concat(COMPONENT_NAME, ".getTempFileURL] fileList must not be empty"),
+                            }));
+                        }
+                        convertedFileList = [];
+                        for (_i = 0, fileList_2 = fileList; _i < fileList_2.length; _i++) {
+                            file = fileList_2[_i];
+                            if (isPalinObject(file)) {
+                                if (!Object.prototype.hasOwnProperty.call(file, 'fileID')) {
+                                    throw new Error(JSON.stringify({
+                                        code: ERRORS.INVALID_PARAMS,
+                                        msg: "[".concat(COMPONENT_NAME, ".getTempFileURL] file info must include fileID"),
+                                    }));
+                                }
+                                convertedFileList.push({
+                                    fileid: file.fileID,
+                                    max_age: file.maxAge || 7200,
+                                });
+                            }
+                            else if (isString(file)) {
+                                convertedFileList.push({
+                                    fileid: file,
+                                });
+                            }
+                            else {
+                                throw new Error(JSON.stringify({
+                                    code: ERRORS.INVALID_PARAMS,
+                                    msg: "[".concat(COMPONENT_NAME, ".getTempFileURL] invalid fileList"),
+                                }));
+                            }
+                        }
+                        action = 'storage.batchGetDownloadUrl';
+                        request = this.request;
+                        res = {};
+                        if (!this.isGateWay()) return [3, 2];
+                        return [4, storageGateWay.getDownLoadInfo(request, { convertedFileList: convertedFileList }, params.customReqOpts)];
+                    case 1:
+                        res = _a.sent();
+                        return [3, 4];
+                    case 2: return [4, request.send(action, { file_list: convertedFileList }, params.customReqOpts)];
+                    case 3:
+                        res = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (res.code) {
+                            return [2, execCallback(callback, null, res)];
+                        }
+                        return [2, execCallback(callback, null, {
+                                fileList: res.data.download_list,
+                                requestId: res.requestId,
+                            })];
+                }
+            });
+        });
+    };
+    CloudbaseStorage.prototype.downloadFile = function (params, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileID, tmpUrlRes, res, request, tmpUrl, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fileID = params.fileID;
+                        if (!isString(fileID)) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "[".concat(COMPONENT_NAME, ".getTempFileURL] fileID must be string"),
+                            }));
+                        }
+                        return [4, this.getTempFileURL.call(this, {
+                                fileList: [
+                                    {
+                                        fileID: fileID,
+                                        maxAge: 600,
+                                    },
+                                ],
+                                customReqOpts: params.customReqOpts,
+                            })];
+                    case 1:
+                        tmpUrlRes = _a.sent();
+                        res = tmpUrlRes.fileList[0];
+                        if (res.code !== 'SUCCESS') {
+                            return [2, execCallback(callback, res)];
+                        }
+                        request = this.request;
+                        tmpUrl = encodeURI(res.download_url);
+                        return [4, request.download({ url: tmpUrl, tempFilePath: params.tempFilePath })];
+                    case 2:
+                        result = _a.sent();
+                        return [2, execCallback(callback, null, result)];
+                }
+            });
+        });
+    };
+    CloudbaseStorage.prototype.copyFile = function (params, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileList, convertedFileList, _i, fileList_3, file, srcPath, dstPath, request, res, action;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fileList = params.fileList;
+                        if (!fileList || !isArray(fileList) || fileList.length === 0) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "[".concat(COMPONENT_NAME, ".copyFile] fileList must not be empty"),
+                            }));
+                        }
+                        convertedFileList = [];
+                        for (_i = 0, fileList_3 = fileList; _i < fileList_3.length; _i++) {
+                            file = fileList_3[_i];
+                            srcPath = file.srcPath, dstPath = file.dstPath;
+                            if (!srcPath || !dstPath || typeof srcPath !== 'string' || typeof dstPath !== 'string') {
+                                throw new Error(JSON.stringify({
+                                    code: ERRORS.INVALID_PARAMS,
+                                    msg: "[".concat(COMPONENT_NAME, ".copyFile] srcPath and dstPath may not be empty"),
+                                }));
+                            }
+                            if (srcPath === dstPath) {
+                                throw new Error(JSON.stringify({
+                                    code: ERRORS.INVALID_PARAMS,
+                                    msg: "[".concat(COMPONENT_NAME, ".copyFile] srcPath and dstPath can not be the same"),
+                                }));
+                            }
+                            convertedFileList.push({
+                                src_path: srcPath,
+                                dst_path: dstPath,
+                                overwrite: file.overwrite,
+                                remove_original: file.removeOriginal,
+                            });
+                        }
+                        request = this.request;
+                        res = {};
+                        if (!this.isGateWay()) return [3, 2];
+                        return [4, storageGateWay.copyFile(request, { convertedFileList: convertedFileList }, params.customReqOpts)];
+                    case 1:
+                        res = _a.sent();
+                        return [3, 4];
+                    case 2:
+                        action = 'storage.batchCopyFile';
+                        return [4, request.send(action, { file_list: convertedFileList }, params.customReqOpts)];
+                    case 3:
+                        res = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (res.code) {
+                            return [2, execCallback(callback, null, res)];
+                        }
+                        return [2, execCallback(callback, null, {
+                                fileList: res.data.copy_list,
+                                requestId: res.requestId,
+                            })];
+                }
+            });
+        });
+    };
+    CloudbaseStorage.prototype.getFileInfo = function (params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var fileInfo, fileList;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4, this.getTempFileURL(params)];
+                    case 1:
+                        fileInfo = _b.sent();
+                        if (!((fileInfo === null || fileInfo === void 0 ? void 0 : fileInfo.fileList) && ((_a = fileInfo === null || fileInfo === void 0 ? void 0 : fileInfo.fileList) === null || _a === void 0 ? void 0 : _a.length) > 0)) return [3, 3];
+                        return [4, Promise.all(fileInfo.fileList.map(function (item) { return __awaiter(_this, void 0, void 0, function () {
+                                var request, res, header, fileSize, contentType, fileInfo_1, e_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (item.code !== 'SUCCESS') {
+                                                return [2, {
+                                                        code: item.code,
+                                                        fileID: item.fileID,
+                                                        tempFileURL: item.tempFileURL,
+                                                        message: item.message,
+                                                    }];
+                                            }
+                                            _a.label = 1;
+                                        case 1:
+                                            _a.trys.push([1, 3, , 4]);
+                                            request = this.request;
+                                            return [4, request.fetch({ url: item.tempFileURL, method: 'HEAD' })];
+                                        case 2:
+                                            res = _a.sent();
+                                            header = res.header;
+                                            if (Headers && header instanceof Headers) {
+                                                header = Object.fromEntries(res.header.entries());
+                                            }
+                                            fileSize = parseInt(header['content-length']) || 0;
+                                            contentType = header['content-type'] || '';
+                                            if ([400, 404].includes(Number(res.statusCode))) {
+                                                return [2, {
+                                                        code: 'FILE_NOT_FOUND',
+                                                        fileID: item.fileID,
+                                                        tempFileURL: item.tempFileURL,
+                                                        message: 'file not found',
+                                                    }];
+                                            }
+                                            fileInfo_1 = {
+                                                code: item.code,
+                                                fileID: item.fileID,
+                                                tempFileURL: item.tempFileURL,
+                                                cloudId: item.fileID,
+                                                fileName: item.fileID.split('/').pop(),
+                                                contentType: contentType,
+                                                mime: contentType.split(';')[0].trim(),
+                                                size: fileSize,
+                                                etag: header.etag || '',
+                                                lastModified: header['last-modified'] || '',
+                                                cacheControl: header['cache-control'] || '',
+                                            };
+                                            return [2, fileInfo_1];
+                                        case 3:
+                                            e_1 = _a.sent();
+                                            return [2, {
+                                                    code: 'FETCH_FILE_INFO_ERROR',
+                                                    fileID: item.fileID,
+                                                    tempFileURL: item.tempFileURL,
+                                                    message: e_1.message,
+                                                }];
+                                        case 4: return [2];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        fileList = _b.sent();
+                        return [2, {
+                                fileList: fileList,
+                                requestId: fileInfo.requestId,
+                            }];
+                    case 3: return [2, {
+                            fileList: [],
+                            requestId: fileInfo.requestId,
+                        }];
+                }
+            });
+        });
+    };
+    __decorate([
+        catchErrorsDecorator({
+            customInfo: {
+                className: 'Cloudbase',
+                methodName: 'uploadFile',
+            },
+            title: '上传文件失败',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 uploadFile() 的语法或参数是否正确',
+                '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+                '  3 - 云存储安全规则是否限制了当前登录状态访问',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", Promise)
+    ], CloudbaseStorage.prototype, "uploadFile", null);
+    __decorate([
+        catchErrorsDecorator({
+            customInfo: {
+                className: 'Cloudbase',
+                methodName: 'getUploadMetadata',
+            },
+            title: '获取上传元信息失败',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 getUploadMetadata() 的语法或参数是否正确',
+                '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+                '  3 - 云存储安全规则是否限制了当前登录状态访问',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", Promise)
+    ], CloudbaseStorage.prototype, "getUploadMetadata", null);
+    __decorate([
+        catchErrorsDecorator({
+            customInfo: {
+                className: 'Cloudbase',
+                methodName: 'deleteFile',
+            },
+            title: '删除文件失败',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 deleteFile() 的语法或参数是否正确',
+                '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+                '  3 - 云存储安全规则是否限制了当前登录状态访问',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", Promise)
+    ], CloudbaseStorage.prototype, "deleteFile", null);
+    __decorate([
+        catchErrorsDecorator({
+            customInfo: {
+                className: 'Cloudbase',
+                methodName: 'getTempFileURL',
+            },
+            title: '获取文件下载链接',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 getTempFileURL() 的语法或参数是否正确',
+                '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+                '  3 - 云存储安全规则是否限制了当前登录状态访问',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", Promise)
+    ], CloudbaseStorage.prototype, "getTempFileURL", null);
+    __decorate([
+        catchErrorsDecorator({
+            customInfo: {
+                className: 'Cloudbase',
+                methodName: 'downloadFile',
+            },
+            title: '下载文件失败',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 downloadFile() 的语法或参数是否正确',
+                '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+                '  3 - 云存储安全规则是否限制了当前登录状态访问',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", Promise)
+    ], CloudbaseStorage.prototype, "downloadFile", null);
+    __decorate([
+        catchErrorsDecorator({
+            customInfo: {
+                className: 'Cloudbase',
+                methodName: 'copyFile',
+            },
+            title: '批量复制文件',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 copyFile() 的语法或参数是否正确',
+                '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',
+                '  3 - 云存储安全规则是否限制了当前登录状态访问',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Function]),
+        __metadata("design:returntype", Promise)
+    ], CloudbaseStorage.prototype, "copyFile", null);
+    return CloudbaseStorage;
+}());
 var storage = new CloudbaseStorage();
 var component = {
     name: COMPONENT_NAME,
@@ -14,6 +725,642 @@ var component = {
         isGateWay: storage.isGateWay,
     },
 };
+var SupabaseFileAPILikeStorage = (function (_super) {
+    __extends(SupabaseFileAPILikeStorage, _super);
+    function SupabaseFileAPILikeStorage(context) {
+        var _this = _super.call(this) || this;
+        _this.shouldThrowOnError = false;
+        _this.bucketId = '';
+        _this.context = context;
+        return _this;
+    }
+    Object.defineProperty(SupabaseFileAPILikeStorage.prototype, "config", {
+        get: function () {
+            var _a;
+            return (_a = this.context) === null || _a === void 0 ? void 0 : _a.config;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SupabaseFileAPILikeStorage.prototype, "request", {
+        get: function () {
+            var _a;
+            return (_a = this.context) === null || _a === void 0 ? void 0 : _a.request;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SupabaseFileAPILikeStorage.prototype.throwOnError = function () {
+        this.shouldThrowOnError = true;
+        return this;
+    };
+    SupabaseFileAPILikeStorage.prototype.from = function (bucket) {
+        this.bucketId = bucket || '';
+        return this;
+    };
+    SupabaseFileAPILikeStorage.prototype.upload = function (path, fileBody, fileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var options, cacheControl, contentType, metadata, cloudPath, uploadFileParams, headers, result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        options = __assign({ upsert: true }, fileOptions);
+                        cacheControl = options.cacheControl, contentType = options.contentType, metadata = options.metadata;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        cloudPath = this._getCloudPath(path);
+                        uploadFileParams = {
+                            cloudPath: cloudPath,
+                            filePath: fileBody,
+                        };
+                        if (cacheControl || contentType || metadata) {
+                            headers = {};
+                            if (cacheControl) {
+                                headers['cache-control'] = cacheControl;
+                            }
+                            if (contentType) {
+                                headers['content-type'] = contentType;
+                            }
+                            if (metadata) {
+                                headers['x-cos-metadata-metadata'] = this.toBase64(JSON.stringify(metadata));
+                            }
+                            uploadFileParams.headers = headers;
+                        }
+                        return [4, this.uploadFile(uploadFileParams)];
+                    case 2:
+                        result = _a.sent();
+                        if (!result.fileID) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.OPERATION_FAIL,
+                                msg: "[".concat(COMPONENT_NAME, ".update] no fileID returned"),
+                            }));
+                        }
+                        return [2, {
+                                data: {
+                                    id: result.fileID,
+                                    path: path,
+                                    fullPath: path,
+                                },
+                                error: null,
+                            }];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_1;
+                        if (isStorageError(error_1)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_1,
+                                }];
+                        }
+                        throw error_1;
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.uploadToSignedUrl = function (path, _token, fileBody, fileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.upload(path, fileBody, fileOptions)];
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.createSignedUploadUrl = function (path) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cloudPath, metadata, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        cloudPath = this._getCloudPath(path);
+                        return [4, this.getUploadMetadata({ cloudPath: cloudPath })];
+                    case 1:
+                        metadata = (_a.sent()).data;
+                        return [2, {
+                                data: {
+                                    signedUrl: metadata.url,
+                                    token: metadata.token,
+                                    path: path,
+                                    authorization: metadata.authorization,
+                                    id: metadata.fileId,
+                                    cosFileId: metadata.cosFileId,
+                                    downloadUrl: metadata.download_url,
+                                },
+                                error: null,
+                            }];
+                    case 2:
+                        error_2 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_2;
+                        return [2, {
+                                data: null,
+                                error: error_2 instanceof StorageError ? error_2 : new StorageError(error_2.message),
+                            }];
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.update = function (path, fileBody, fileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.upload(path, fileBody, __assign(__assign({}, fileOptions), { upsert: true }))];
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.move = function (fromPath, toPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.copyFile({
+                                fileList: [
+                                    {
+                                        srcPath: this._getCloudPath(fromPath),
+                                        dstPath: this._getCloudPath(toPath),
+                                        overwrite: true,
+                                        removeOriginal: true,
+                                    },
+                                ],
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {
+                            throw new StorageError(result.fileList[0].message || 'Move failed');
+                        }
+                        return [2, {
+                                data: { message: "File moved from ".concat(fromPath, " to ").concat(toPath) },
+                                error: null,
+                            }];
+                    case 2:
+                        error_3 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_3;
+                        if (isStorageError(error_3)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_3,
+                                }];
+                        }
+                        throw error_3;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.copy = function (fromPath, toPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.copyFile({
+                                fileList: [
+                                    {
+                                        srcPath: this._getCloudPath(fromPath),
+                                        dstPath: this._getCloudPath(toPath),
+                                        overwrite: true,
+                                        removeOriginal: false,
+                                    },
+                                ],
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {
+                            throw new StorageError(result.fileList[0].message || 'Copy failed');
+                        }
+                        return [2, {
+                                data: { path: this._getCloudPath(toPath) },
+                                error: null,
+                            }];
+                    case 2:
+                        error_4 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_4;
+                        if (isStorageError(error_4)) {
+                            return [2, { data: null, error: error_4 }];
+                        }
+                        throw error_4;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.createSignedUrl = function (path, expiresIn, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cloudPath, result, signedUrl, queryParams, transformQuery, separator, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        cloudPath = this._normalizeCloudId(path);
+                        return [4, this.getTempFileURL({
+                                fileList: [
+                                    {
+                                        fileID: cloudPath,
+                                        maxAge: expiresIn,
+                                    },
+                                ],
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (result.fileList[0].code !== 'SUCCESS') {
+                            throw new StorageError("Failed to create signed URL: [".concat(result.fileList[0].code, "] ").concat(result.fileList[0].fileID));
+                        }
+                        signedUrl = result.fileList[0].download_url;
+                        queryParams = [];
+                        if ((options === null || options === void 0 ? void 0 : options.download) !== undefined) {
+                            if (typeof options.download === 'string') {
+                                queryParams.push("download=".concat(encodeURIComponent(options.download)));
+                            }
+                            else if (options.download === true) {
+                                queryParams.push('download=true');
+                            }
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.transform) {
+                            transformQuery = this._transformOptsToQueryString(options.transform);
+                            if (transformQuery) {
+                                queryParams.push(transformQuery);
+                            }
+                        }
+                        if (queryParams.length > 0) {
+                            separator = signedUrl.includes('?') ? '&' : '?';
+                            signedUrl = "".concat(signedUrl).concat(separator).concat(queryParams.join('&'));
+                        }
+                        return [2, {
+                                data: { signedUrl: signedUrl },
+                                error: null,
+                            }];
+                    case 2:
+                        error_5 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_5;
+                        if (isStorageError(error_5)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_5,
+                                }];
+                        }
+                        throw error_5;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.createSignedUrls = function (paths, expiresIn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileList, result, error_6;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        fileList = paths.map(function (p) { return ({
+                            fileID: _this._normalizeCloudId(p),
+                            maxAge: expiresIn,
+                        }); });
+                        return [4, this.getTempFileURL({ fileList: fileList })];
+                    case 1:
+                        result = _a.sent();
+                        return [2, {
+                                data: result.fileList.map(function (item, index) { return ({
+                                    path: paths[index],
+                                    signedUrl: item.tempFileURL || '',
+                                    error: item.code === 'SUCCESS' ? null : item.message,
+                                }); }),
+                                error: null,
+                            }];
+                    case 2:
+                        error_6 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_6;
+                        if (isStorageError(error_6)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_6,
+                                }];
+                        }
+                        throw error_6;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.download = function (path, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_7;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        _a = {};
+                        return [4, (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var signedUrlResult, tmpUrl, data;
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0: return [4, this.createSignedUrl(path, 600, { transform: options })];
+                                        case 1:
+                                            signedUrlResult = _b.sent();
+                                            if (signedUrlResult.error) {
+                                                throw signedUrlResult.error;
+                                            }
+                                            tmpUrl = encodeURI((_a = signedUrlResult.data) === null || _a === void 0 ? void 0 : _a.signedUrl);
+                                            return [4, this.request.reqClass.get({
+                                                    url: tmpUrl,
+                                                    headers: {},
+                                                    responseType: 'blob',
+                                                })];
+                                        case 2:
+                                            data = (_b.sent()).data;
+                                            if (!data) {
+                                                throw new StorageError('Download failed: no file content');
+                                            }
+                                            return [2, new Blob([data])];
+                                    }
+                                });
+                            }); })()];
+                    case 1: return [2, (_a.data = _b.sent(),
+                            _a.error = null,
+                            _a)];
+                    case 2:
+                        error_7 = _b.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_7;
+                        if (isStorageError(error_7)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_7,
+                                }];
+                        }
+                        throw error_7;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.info = function (pathOrFileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isFileId, displayName, bucketId, fileInfo, item, now, lastModified, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        isFileId = pathOrFileId.startsWith('cloud://');
+                        displayName = isFileId ? this._extractPathFromFileId(pathOrFileId) : pathOrFileId;
+                        bucketId = isFileId ? this._extractBucketFromFileId(pathOrFileId) : this.bucketId;
+                        return [4, this.getFileInfo({
+                                fileList: [this._normalizeCloudId(pathOrFileId)],
+                            })];
+                    case 1:
+                        fileInfo = _a.sent();
+                        item = fileInfo.fileList[0];
+                        if (item.code !== 'SUCCESS') {
+                            throw new StorageError(item.message);
+                        }
+                        now = new Date().toISOString();
+                        lastModified = (item.lastModified ? new Date(item.lastModified) : new Date()).toISOString();
+                        return [2, {
+                                data: {
+                                    id: item.fileID,
+                                    version: '1',
+                                    name: displayName,
+                                    bucketId: bucketId,
+                                    updatedAt: lastModified,
+                                    createdAt: lastModified,
+                                    lastAccessedAt: now,
+                                    size: item.size,
+                                    cacheControl: item.cacheControl,
+                                    contentType: item.contentType,
+                                    etag: item.etag,
+                                    lastModified: lastModified,
+                                    metadata: {},
+                                },
+                                error: null,
+                            }];
+                    case 2:
+                        error_8 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_8;
+                        return [2, {
+                                data: null,
+                                error: error_8 instanceof StorageError ? error_8 : new StorageError(error_8.message),
+                            }];
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.exists = function (pathOrFileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileInfo, item, error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.getFileInfo({
+                                fileList: [this._normalizeCloudId(pathOrFileId)],
+                            })];
+                    case 1:
+                        fileInfo = _a.sent();
+                        item = fileInfo.fileList[0];
+                        if (item.code === 'FILE_NOT_FOUND') {
+                            return [2, {
+                                    data: false,
+                                    error: null,
+                                }];
+                        }
+                        if (item.code !== 'SUCCESS') {
+                            throw new StorageError(item.message);
+                        }
+                        return [2, { data: true, error: null }];
+                    case 2:
+                        error_9 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_9;
+                        throw error_9;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.getPublicUrl = function (path, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.createSignedUrl(path, 600, options)];
+                    case 1:
+                        res = _a.sent();
+                        if (res.data) {
+                            return [2, {
+                                    data: { publicUrl: res.data.signedUrl },
+                                }];
+                        }
+                        return [2, { data: null, error: res.error }];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.remove = function (paths) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunkSize_1, pathChunks, i, fileInfoResults, fileInfoMap_1, fileList, result, failedFiles, now_1, error_10;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        chunkSize_1 = 10;
+                        pathChunks = [];
+                        for (i = 0; i < paths.length; i += chunkSize_1) {
+                            pathChunks.push(paths.slice(i, i + chunkSize_1));
+                        }
+                        return [4, Promise.all(pathChunks.map(function (chunk) { return Promise.all(chunk.map(function (path) { return _this.info(path); })); }))];
+                    case 1:
+                        fileInfoResults = _a.sent();
+                        fileInfoMap_1 = new Map();
+                        fileInfoResults.flat().forEach(function (result, index) {
+                            if (result.data) {
+                                fileInfoMap_1.set(paths[Math.floor(index / chunkSize_1) * chunkSize_1 + (index % chunkSize_1)], result.data);
+                            }
+                        });
+                        fileList = paths.map(function (p) { return _this._normalizeCloudId(p); });
+                        return [4, this.deleteFile({ fileList: fileList })];
+                    case 2:
+                        result = _a.sent();
+                        failedFiles = result.fileList.filter(function (item) { return item.code !== 'SUCCESS'; });
+                        if (failedFiles.length > 0) {
+                            throw new StorageError("Delete failed for ".concat(failedFiles.length, " file(s)"));
+                        }
+                        now_1 = new Date().toISOString();
+                        return [2, {
+                                data: paths.map(function (p) {
+                                    var info = fileInfoMap_1.get(p);
+                                    return {
+                                        name: info === null || info === void 0 ? void 0 : info.name,
+                                        id: info === null || info === void 0 ? void 0 : info.id,
+                                        bucket_id: info === null || info === void 0 ? void 0 : info.bucketId,
+                                        owner: undefined,
+                                        updated_at: (info === null || info === void 0 ? void 0 : info.updatedAt) || now_1,
+                                        created_at: info === null || info === void 0 ? void 0 : info.createdAt,
+                                        last_accessed_at: (info === null || info === void 0 ? void 0 : info.lastAccessedAt) || now_1,
+                                        metadata: (info === null || info === void 0 ? void 0 : info.metadata) || {},
+                                        buckets: {
+                                            id: info === null || info === void 0 ? void 0 : info.bucketId,
+                                            name: info === null || info === void 0 ? void 0 : info.bucketId,
+                                            owner: undefined,
+                                            public: false,
+                                            created_at: '',
+                                            updated_at: now_1,
+                                        },
+                                    };
+                                }),
+                                error: null,
+                            }];
+                    case 3:
+                        error_10 = _a.sent();
+                        if (this.shouldThrowOnError)
+                            throw error_10;
+                        if (isStorageError(error_10)) {
+                            return [2, {
+                                    data: null,
+                                    error: error_10,
+                                }];
+                        }
+                        throw error_10;
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype.list = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new StorageError('Not implemented');
+            });
+        });
+    };
+    SupabaseFileAPILikeStorage.prototype._getCloudPath = function (path) {
+        var cleanPath = path.replace(/^\/|\/$/g, '').replace(/\/+/g, '/');
+        return cleanPath;
+    };
+    SupabaseFileAPILikeStorage.prototype._normalizeCloudId = function (path) {
+        var _a;
+        if (/^cloud:\/\//.test(path)) {
+            return path;
+        }
+        var cleanPath = this._getCloudPath(path);
+        if (this.bucketId) {
+            var envId = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.env) || '';
+            if (envId) {
+                return "cloud://".concat(envId, ".").concat(this.bucketId, "/").concat(cleanPath);
+            }
+        }
+        else {
+            throw new StorageError('bucketId is not set');
+        }
+    };
+    SupabaseFileAPILikeStorage.prototype.toBase64 = function (data) {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(data).toString('base64');
+        }
+        return btoa(data);
+    };
+    SupabaseFileAPILikeStorage.prototype._transformOptsToQueryString = function (transform) {
+        var params = ['imageMogr2'];
+        if (transform.width || transform.height) {
+            var width = transform.width || '';
+            var height = transform.height || '';
+            if (transform.resize === 'fill') {
+                params.push("thumbnail/".concat(width, "x").concat(height, "!"));
+            }
+            else if (transform.resize === 'contain') {
+                params.push("thumbnail/".concat(width, "x").concat(height));
+            }
+            else {
+                params.push("thumbnail/".concat(width, "x").concat(height, "^"));
+            }
+        }
+        if (transform.format && transform.format !== 'origin') {
+            params.push("format/".concat(transform.format));
+        }
+        if (transform.quality !== undefined) {
+            var quality = Math.max(1, Math.min(100, transform.quality));
+            params.push("quality/".concat(quality));
+        }
+        return params.join('/');
+    };
+    SupabaseFileAPILikeStorage.prototype._extractPathFromFileId = function (fileId) {
+        var withoutProtocol = fileId.replace(/^cloud:\/\//, '');
+        var parts = withoutProtocol.split('/');
+        if (parts.length < 2) {
+            return fileId;
+        }
+        return parts.slice(1).join('/');
+    };
+    SupabaseFileAPILikeStorage.prototype._extractBucketFromFileId = function (fileId) {
+        var withoutProtocol = fileId.replace(/^cloud:\/\//, '');
+        var parts = withoutProtocol.split('/');
+        if (parts.length < 1) {
+            return '';
+        }
+        var envAndBucket = parts[0];
+        var dotIndex = envAndBucket.indexOf('.');
+        if (dotIndex === -1) {
+            return envAndBucket;
+        }
+        return envAndBucket.substring(dotIndex + 1);
+    };
+    return SupabaseFileAPILikeStorage;
+}(CloudbaseStorage));
+export { SupabaseFileAPILikeStorage };
 var supabaseComponent = {
     name: "".concat(COMPONENT_NAME, "/supabase"),
     IIFE: true,
@@ -63,4 +1410,4 @@ try {
     window.registerStorage = registerStorage;
 }
 catch (e) { }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { ICloudbase } from '@cloudbase/types'\nimport { ICloudbaseComponent } from '@cloudbase/types/component'\nimport { Camelize, FileBody, FileObject, FileObjectV2, FileOptions, TransformOptions } from './supabase/types'\nimport { isStorageError, StorageError } from './supabase/errors'\nimport { constants, utils, helpers } from '@cloudbase/utilities'\nimport {\n  ICloudbaseFileMetaDataRes,\n  ICloudbaseFileInfo,\n  ICloudbaseUploadFileParams,\n  ICloudbaseUploadFileResult,\n  ICloudbaseGetUploadMetadataParams,\n  ICloudbaseDeleteFileParams,\n  ICloudbaseDeleteFileResult,\n  ICloudbaseGetTempFileURLResult,\n  ICloudbaseGetTempFileURLParams,\n  ICloudbaseDownloadFileResult,\n  ICloudbaseDownloadFileParams,\n  ICloudbaseCopyFileParams,\n  ICloudbaseCopyFileResult,\n} from '@cloudbase/types/storage'\n\nenum EUploadMethod {\n  put = 'put',\n  post = 'post',\n}\n\ninterface IUploadMetadata {\n  url: string\n  token: string\n  authorization: string\n  fileId: string\n  cosFileId: string\n  download_url?: string\n}\n\nconst { getSdkName, ERRORS, COMMUNITY_SITE_URL } = constants\nconst { isArray, isString, isPalinObject, execCallback } = utils\n/** catchErrorsDecorator 装饰器要放在index入口文件，意面有的编译找不到其sourcemap，例如HBuilderX */\nconst { catchErrorsDecorator } = helpers\n\nexport const COMPONENT_NAME = 'storage'\n\nconst storageGateWay = {\n  getUploadInfo: async (\n    request,\n    params: { path: string; headers?: Record<string, string> },\n    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],\n  ) => {\n    let res = await request.gateWay(\n      {\n        path: 'storages',\n        name: 'get-objects-upload-info',\n        data: [\n          {\n            objectId: params.path,\n            ...(params.headers ? { signedHeader: params.headers } : {}),\n          },\n        ],\n      },\n      customReqOpts,\n    )\n    const data = res.data?.[0] || {}\n\n    res = {\n      ...res,\n      data: {\n        ...(data.code ? { ...data } : {}),\n        authorization: data.authorization,\n        token: data.token,\n        url: data.uploadUrl,\n        fileId: data.cloudObjectId,\n        cosFileId: data.cloudObjectMeta,\n        download_url: data.downloadUrl,\n      },\n    }\n\n    return res\n  },\n  getDownLoadInfo: async (\n    request,\n    params: { convertedFileList: Array<{ fileid: string }> },\n    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],\n  ) => {\n    let res = await request.gateWay(\n      {\n        path: 'storages',\n        name: 'get-objects-download-info',\n        data: params.convertedFileList.map((v: any) => ({ cloudObjectId: v.fileid })),\n      },\n      customReqOpts,\n    )\n    res = {\n      ...res,\n      data: {\n        download_list: res.data?.map(v => ({\n          code: v.code || 'SUCCESS',\n          message: v.message,\n          fileid: v.cloudObjectId,\n          download_url: v.downloadUrl,\n          fileID: v.cloudObjectId,\n          tempFileURL: v.downloadUrl,\n        })),\n      },\n    }\n\n    return res\n  },\n  delete: async (\n    request,\n    params: { fileList: Array<string> },\n    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],\n  ) => {\n    let res = await request.gateWay(\n      {\n        path: 'storages',\n        name: 'delete-objects',\n        data: params.fileList.map(v => ({ cloudObjectId: v })),\n      },\n      customReqOpts,\n    )\n    res = {\n      ...res,\n      data: {\n        delete_list: res.data?.map(v => ({\n          code: v.code || 'SUCCESS',\n          fileID: v.cloudObjectId,\n          message: v.message,\n        })),\n      },\n    }\n\n    return res\n  },\n  copyFile: async (\n    request,\n    params: {\n      convertedFileList: Array<{ src_path: string; dst_path: string; overwrite: boolean; remove_original: boolean }>\n    },\n    customReqOpts: ICloudbaseUploadFileParams['customReqOpts'],\n  ) => {\n    let res = await request.gateWay(\n      {\n        path: 'storages',\n        name: 'copy-objects',\n        data: params.convertedFileList.map((v: any) => ({\n          srcPath: v.src_path,\n          dstPath: v.dst_path,\n          overwrite: v.overwrite,\n          removeOriginal: v.remove_original,\n        })),\n      },\n      customReqOpts,\n    )\n    res = {\n      ...res,\n      data: {\n        copy_list: res.data?.map(v => ({\n          code: v.code || 'SUCCESS',\n          fileID: v.cloudObjectId,\n          message: v.message,\n        })),\n      },\n    }\n\n    return res\n  },\n}\n\nexport interface ICloudbaseContext {\n  config: any\n  request: any\n}\n\nexport class CloudbaseStorage {\n  public isGateWay() {\n    // @ts-ignore\n    const { config } = this\n    const endPointMode = config.endPointMode || 'CLOUD_API'\n\n    return endPointMode === 'GATEWAY'\n  }\n\n  @catchErrorsDecorator({\n    customInfo: {\n      className: 'Cloudbase',\n      methodName: 'uploadFile',\n    },\n    title: '上传文件失败',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 uploadFile() 的语法或参数是否正确',\n      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',\n      '  3 - 云存储安全规则是否限制了当前登录状态访问',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async uploadFile(\n    params: Omit<ICloudbaseUploadFileParams, 'filePath'> & { filePath?: string },\n    callback?: Function,\n  ): Promise<ICloudbaseUploadFileResult> {\n    const { cloudPath, filePath, onUploadProgress, method = 'put', headers = {}, fileContent } = params\n    if (!isString(cloudPath) || (!filePath && !fileContent)) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `[${COMPONENT_NAME}.uploadFile] invalid params`,\n      }),)\n    }\n    const uploadMethod =      { put: EUploadMethod.put, post: EUploadMethod.post }[method.toLocaleLowerCase()] || EUploadMethod.put\n\n    // 调用 getUploadMetadata 获取上传元数据\n    const metadataResult = await this.getUploadMetadata({\n      cloudPath,\n      method: uploadMethod,\n      headers: uploadMethod === EUploadMethod.put ? headers : undefined,\n      customReqOpts: params.customReqOpts,\n    })\n\n    const { data: metadata, requestId } = metadataResult\n    const { url, authorization, token, fileId, cosFileId, download_url: downloadUrl } = metadata\n\n    const commonParams = {\n      url,\n      file: filePath,\n      name: cloudPath,\n      onUploadProgress,\n      fileContent,\n      fileId,\n      requestId,\n    }\n\n    const putParams = {\n      ...commonParams,\n      method: EUploadMethod.put,\n      headers: {\n        ...headers,\n        authorization,\n        'x-cos-meta-fileid': cosFileId,\n        'x-cos-security-token': token,\n      },\n    }\n\n    const postParams = {\n      ...commonParams,\n      method: EUploadMethod.post,\n      data: {\n        key: cloudPath,\n        signature: authorization,\n        'x-cos-meta-fileid': cosFileId,\n        success_action_status: '201',\n        'x-cos-security-token': token,\n      },\n    }\n\n    const uploadConfig = {\n      [EUploadMethod.put]: {\n        params: putParams,\n        isSuccess: (code: number) => code >= 200 && code < 300,\n      },\n      [EUploadMethod.post]: {\n        params: postParams,\n        isSuccess: (code: number) => code === 201,\n      },\n    }\n\n    // @ts-ignore\n    const res = await this.request.upload(uploadConfig[uploadMethod].params)\n\n    if (uploadConfig[uploadMethod].isSuccess(res.statusCode)) {\n      return execCallback(callback, null, {\n        fileID: fileId,\n        download_url: downloadUrl,\n        requestId,\n      })\n    }\n    return execCallback(\n      callback,\n      new Error(`[${getSdkName()}][${ERRORS.OPERATION_FAIL}][${COMPONENT_NAME}]:${res.data}`),\n    )\n  }\n  @catchErrorsDecorator({\n    customInfo: {\n      className: 'Cloudbase',\n      methodName: 'getUploadMetadata',\n    },\n    title: '获取上传元信息失败',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 getUploadMetadata() 的语法或参数是否正确',\n      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',\n      '  3 - 云存储安全规则是否限制了当前登录状态访问',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async getUploadMetadata(\n    params: ICloudbaseGetUploadMetadataParams & {\n      method?: EUploadMethod\n      headers?: Record<string, string>\n    },\n    callback?: Function,\n  ): Promise<{ data: IUploadMetadata; requestId: string }> {\n    const { cloudPath, method, headers } = params\n    if (!isString(cloudPath)) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `[${COMPONENT_NAME}.getUploadMetadata] invalid cloudPath`,\n      }),)\n    }\n    // @ts-ignore\n    const { request } = this\n    const action = 'storage.getUploadMetadata'\n\n    try {\n      let metaData: ICloudbaseFileMetaDataRes\n\n      const metaDataParam: {\n        path: string\n        method?: EUploadMethod\n        headers?: Record<string, string>\n      } = { path: cloudPath }\n\n      if (method) {\n        metaDataParam.method = method\n      }\n      if (method === EUploadMethod.put && headers) {\n        metaDataParam.headers = headers\n      }\n\n      if (this.isGateWay()) {\n        metaData = await storageGateWay.getUploadInfo(request, metaDataParam, params.customReqOpts)\n      } else {\n        metaData = await request.send(action, metaDataParam, params.customReqOpts)\n      }\n      return execCallback(callback, null, metaData)\n    } catch (err) {\n      return execCallback(callback, err)\n    }\n  }\n  @catchErrorsDecorator({\n    customInfo: {\n      className: 'Cloudbase',\n      methodName: 'deleteFile',\n    },\n    title: '删除文件失败',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 deleteFile() 的语法或参数是否正确',\n      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',\n      '  3 - 云存储安全规则是否限制了当前登录状态访问',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async deleteFile(\n    params: ICloudbaseDeleteFileParams,\n    callback?: Function,\n  ): Promise<ICloudbaseDeleteFileResult> {\n    const { fileList } = params\n\n    if (!fileList || !isArray(fileList) || fileList.length === 0) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `[${COMPONENT_NAME}.deleteFile] fileList must not be empty`,\n      }),)\n    }\n\n    for (const fileId of fileList) {\n      if (!fileId || !isString(fileId)) {\n        throw new Error(JSON.stringify({\n          code: ERRORS.INVALID_PARAMS,\n          msg: `[${COMPONENT_NAME}.deleteFile] fileID must be string`,\n        }),)\n      }\n    }\n\n    const action = 'storage.batchDeleteFile'\n    // @ts-ignore\n    const { request } = this\n    let res: any = {}\n\n    if (this.isGateWay()) {\n      res = await storageGateWay.delete(request, { fileList }, params.customReqOpts)\n    } else {\n      res = await request.send(\n        action,\n        {\n          fileid_list: fileList,\n        },\n        params.customReqOpts,\n      )\n    }\n\n    if (res.code) {\n      return execCallback(callback, null, res)\n    }\n    const data = {\n      fileList: res.data.delete_list,\n      requestId: res.requestId,\n    }\n    return execCallback(callback, null, data)\n  }\n  @catchErrorsDecorator({\n    customInfo: {\n      className: 'Cloudbase',\n      methodName: 'getTempFileURL',\n    },\n    title: '获取文件下载链接',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 getTempFileURL() 的语法或参数是否正确',\n      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',\n      '  3 - 云存储安全规则是否限制了当前登录状态访问',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async getTempFileURL(\n    params: ICloudbaseGetTempFileURLParams,\n    callback?: Function,\n  ): Promise<ICloudbaseGetTempFileURLResult> {\n    const { fileList } = params\n\n    if (!fileList || !isArray(fileList) || fileList.length === 0) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `[${COMPONENT_NAME}.getTempFileURL] fileList must not be empty`,\n      }),)\n    }\n\n    const convertedFileList = []\n    for (const file of fileList) {\n      if (isPalinObject(file)) {\n        if (!Object.prototype.hasOwnProperty.call(file, 'fileID')) {\n          throw new Error(JSON.stringify({\n            code: ERRORS.INVALID_PARAMS,\n            msg: `[${COMPONENT_NAME}.getTempFileURL] file info must include fileID`,\n          }),)\n        }\n\n        convertedFileList.push({\n          fileid: (file as ICloudbaseFileInfo).fileID,\n          max_age: (file as ICloudbaseFileInfo).maxAge || 7200,\n        })\n      } else if (isString(file)) {\n        convertedFileList.push({\n          fileid: file,\n        })\n      } else {\n        throw new Error(JSON.stringify({\n          code: ERRORS.INVALID_PARAMS,\n          msg: `[${COMPONENT_NAME}.getTempFileURL] invalid fileList`,\n        }),)\n      }\n    }\n\n    const action = 'storage.batchGetDownloadUrl'\n    // @ts-ignore\n    const { request } = this\n    let res: any = {}\n\n    if (this.isGateWay()) {\n      res = await storageGateWay.getDownLoadInfo(request, { convertedFileList }, params.customReqOpts)\n    } else {\n      res = await request.send(action, { file_list: convertedFileList }, params.customReqOpts)\n    }\n\n    if (res.code) {\n      return execCallback(callback, null, res)\n    }\n\n    return execCallback(callback, null, {\n      fileList: res.data.download_list,\n      requestId: res.requestId,\n    })\n  }\n  @catchErrorsDecorator({\n    customInfo: {\n      className: 'Cloudbase',\n      methodName: 'downloadFile',\n    },\n    title: '下载文件失败',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 downloadFile() 的语法或参数是否正确',\n      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',\n      '  3 - 云存储安全规则是否限制了当前登录状态访问',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async downloadFile(\n    params: ICloudbaseDownloadFileParams,\n    callback?: Function,\n  ): Promise<ICloudbaseDownloadFileResult> {\n    const { fileID } = params\n    if (!isString(fileID)) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `[${COMPONENT_NAME}.getTempFileURL] fileID must be string`,\n      }),)\n    }\n\n    const tmpUrlRes = await this.getTempFileURL.call(this, {\n      fileList: [\n        {\n          fileID,\n          maxAge: 600,\n        },\n      ],\n      customReqOpts: params.customReqOpts,\n    })\n\n    const res = tmpUrlRes.fileList[0]\n\n    if (res.code !== 'SUCCESS') {\n      return execCallback(callback, res)\n    }\n    // @ts-ignore\n    const { request } = this\n\n    const tmpUrl = encodeURI(res.download_url)\n\n    const result = await request.download({ url: tmpUrl, tempFilePath: params.tempFilePath })\n    return execCallback(callback, null, result)\n  }\n  @catchErrorsDecorator({\n    customInfo: {\n      className: 'Cloudbase',\n      methodName: 'copyFile',\n    },\n    title: '批量复制文件',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 copyFile() 的语法或参数是否正确',\n      '  2 - 当前域名是否在安全域名列表中：https://console.cloud.tencent.com/tcb/env/safety',\n      '  3 - 云存储安全规则是否限制了当前登录状态访问',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async copyFile(params: ICloudbaseCopyFileParams, callback?: Function): Promise<ICloudbaseCopyFileResult> {\n    const { fileList } = params\n\n    if (!fileList || !isArray(fileList) || fileList.length === 0) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `[${COMPONENT_NAME}.copyFile] fileList must not be empty`,\n      }),)\n    }\n\n    const convertedFileList = []\n\n    for (const file of fileList) {\n      const { srcPath, dstPath } = file\n      if (!srcPath || !dstPath || typeof srcPath !== 'string' || typeof dstPath !== 'string') {\n        throw new Error(JSON.stringify({\n          code: ERRORS.INVALID_PARAMS,\n          msg: `[${COMPONENT_NAME}.copyFile] srcPath and dstPath may not be empty`,\n        }),)\n      }\n      if (srcPath === dstPath) {\n        throw new Error(JSON.stringify({\n          code: ERRORS.INVALID_PARAMS,\n          msg: `[${COMPONENT_NAME}.copyFile] srcPath and dstPath can not be the same`,\n        }),)\n      }\n      //   if (basename(srcPath) !== basename(dstPath)) {\n      //     throw new Error(JSON.stringify({\n      //       code: ERRORS.INVALID_PARAMS,\n      //       msg: `[${COMPONENT_NAME}.copyFile] srcPath and dstPath file name must be the same`,\n      //     }),)\n      //   }\n      convertedFileList.push({\n        src_path: srcPath,\n        dst_path: dstPath,\n        overwrite: file.overwrite,\n        remove_original: file.removeOriginal,\n      })\n    }\n\n    // @ts-ignore\n    const { request } = this\n    let res: any = {}\n\n    if (this.isGateWay()) {\n      res = await storageGateWay.copyFile(request, { convertedFileList }, params.customReqOpts)\n    } else {\n      const action = 'storage.batchCopyFile'\n      res = await request.send(action, { file_list: convertedFileList }, params.customReqOpts)\n    }\n\n    if (res.code) {\n      return execCallback(callback, null, res)\n    }\n\n    return execCallback(callback, null, {\n      fileList: res.data.copy_list,\n      requestId: res.requestId,\n    })\n  }\n\n  public async getFileInfo(params: ICloudbaseGetTempFileURLParams): Promise<{\n    fileList: (Pick<ICloudbaseGetTempFileURLResult['fileList'][0], 'code' | 'fileID' | 'tempFileURL' | 'message'> & {\n      fileName?: string\n      cloudId?: ICloudbaseGetTempFileURLResult['fileList'][0]['fileID']\n      contentType?: string\n      mime?: string\n      size?: number\n      cacheControl?: string\n      lastModified?: string\n      etag?: string\n    })[]\n    requestId: string\n  }> {\n    const fileInfo = await this.getTempFileURL(params)\n\n    if (fileInfo?.fileList && fileInfo?.fileList?.length > 0) {\n      const fileList = await Promise.all(fileInfo.fileList.map(async (item: ICloudbaseGetTempFileURLResult['fileList'][0]) => {\n        if (item.code !== 'SUCCESS') {\n          return {\n            code: item.code,\n            fileID: item.fileID,\n            tempFileURL: item.tempFileURL,\n            message: item.message,\n          }\n        }\n\n        try {\n          // @ts-ignore\n          const { request } = this\n          const res = await request.fetch({ url: item.tempFileURL, method: 'HEAD' })\n          let { header } = res\n\n          if (Headers && header instanceof Headers) {\n            header = Object.fromEntries(res.header.entries())\n          }\n          // eslint-disable-next-line radix\n          const fileSize = parseInt(header['content-length']) || 0\n          const contentType = header['content-type'] || ''\n\n          if ([400, 404].includes(Number(res.statusCode))) {\n            return {\n              code: 'FILE_NOT_FOUND',\n              fileID: item.fileID,\n              tempFileURL: item.tempFileURL,\n              message: 'file not found',\n            }\n          }\n\n          const fileInfo = {\n            code: item.code,\n            fileID: item.fileID,\n            tempFileURL: item.tempFileURL,\n            cloudId: item.fileID,\n            fileName: item.fileID.split('/').pop(),\n            contentType,\n            mime: contentType.split(';')[0].trim(),\n            size: fileSize,\n            etag: header.etag || '',\n            lastModified: header['last-modified'] || '',\n            cacheControl: header['cache-control'] || '',\n          }\n\n          return fileInfo\n        } catch (e) {\n          return {\n            code: 'FETCH_FILE_INFO_ERROR',\n            fileID: item.fileID,\n            tempFileURL: item.tempFileURL,\n            message: e.message,\n          }\n        }\n      }),)\n\n      return {\n        fileList,\n        requestId: fileInfo.requestId,\n      }\n    }\n\n    return {\n      fileList: [],\n      requestId: fileInfo.requestId,\n    }\n  }\n}\n\n\ndeclare const cloudbase: ICloudbase\n\nconst storage = new CloudbaseStorage()\nconst component: ICloudbaseComponent = {\n  name: COMPONENT_NAME,\n  entity: {\n    uploadFile: storage.uploadFile,\n    deleteFile: storage.deleteFile,\n    getTempFileURL: storage.getTempFileURL,\n    downloadFile: storage.downloadFile,\n    getUploadMetadata: storage.getUploadMetadata,\n    copyFile: storage.copyFile,\n    getFileInfo: storage.getFileInfo,\n    isGateWay: storage.isGateWay,\n  },\n}\n\nexport class SupabaseFileAPILikeStorage extends CloudbaseStorage {\n  private shouldThrowOnError = false\n  private bucketId = ''\n  private context: ICloudbaseContext\n\n  constructor(context?: ICloudbaseContext) {\n    super()\n    this.context = context\n  }\n\n  get config() {\n    // @ts-ignore\n    return this.context?.config\n  }\n\n  get request() {\n    // @ts-ignore\n    return this.context?.request\n  }\n\n  throwOnError(): this {\n    this.shouldThrowOnError = true\n    return this\n  }\n\n  from(bucket?: string) {\n    this.bucketId = bucket || ''\n    return this\n  }\n\n  async upload(\n    path: string,\n    fileBody: FileBody,\n    fileOptions?: FileOptions,\n  ): Promise<\n    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }\n    > {\n    const options = { upsert: true, ...fileOptions }\n    const { cacheControl, contentType, metadata } = options\n    try {\n      const cloudPath = this._getCloudPath(path)\n      const uploadFileParams: Parameters<CloudbaseStorage['uploadFile']>[0] = {\n        cloudPath,\n        filePath: fileBody as any,\n      }\n\n      if (cacheControl || contentType || metadata) {\n        const headers = {}\n        if (cacheControl) {\n          headers['cache-control'] = cacheControl\n        }\n        if (contentType) {\n          headers['content-type'] = contentType\n        }\n\n        if (metadata) {\n          headers['x-cos-metadata-metadata'] = this.toBase64(JSON.stringify(metadata))\n        }\n\n        uploadFileParams.headers = headers\n      }\n\n      const result = await this.uploadFile(uploadFileParams)\n\n      // IUploadFileRes 没有 code 字段，如果没有 fileID 则表示失败\n      if (!result.fileID) {\n        throw new Error(JSON.stringify({\n          code: ERRORS.OPERATION_FAIL,\n          msg: `[${COMPONENT_NAME}.update] no fileID returned`,\n        }),)\n      }\n\n      return {\n        data: {\n          id: result.fileID,\n          path,\n          fullPath: path,\n        },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async uploadToSignedUrl(\n    path: string,\n    _token: string,\n    fileBody: FileBody,\n    fileOptions?: FileOptions,\n  ): Promise<\n    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }\n    > {\n    return this.upload(path, fileBody, fileOptions)\n  }\n\n  async createSignedUploadUrl(path: string): Promise<\n  | {\n    data: {\n      signedUrl: string\n      token: string\n      path: string\n      // CloudBase 额外的元数据字段\n      authorization?: string\n      id?: string\n      cosFileId?: string\n      downloadUrl?: string\n    }\n    error: null\n  }\n  | { data: null; error: StorageError }\n  > {\n    try {\n      const cloudPath = this._getCloudPath(path)\n\n      const { data: metadata } = await this.getUploadMetadata({ cloudPath })\n\n      return {\n        data: {\n          signedUrl: metadata.url,\n          token: metadata.token,\n          path,\n          // 返回 CloudBase 的额外元数据，供 uploadToSignedUrl 使用\n          authorization: metadata.authorization,\n          id: metadata.fileId,\n          cosFileId: metadata.cosFileId,\n          downloadUrl: metadata.download_url,\n        },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      return {\n        data: null,\n        error: error instanceof StorageError ? error : new StorageError(error.message),\n      }\n    }\n  }\n\n  async update(\n    path: string,\n    fileBody: FileBody,\n    fileOptions?: FileOptions,\n  ): Promise<\n    { data: { id: string; path: string; fullPath: string }; error: null } | { data: null; error: StorageError }\n    > {\n    return this.upload(path, fileBody, { ...fileOptions, upsert: true })\n  }\n\n  async move(\n    fromPath: string,\n    toPath: string,\n    // options?: DestinationOptions,\n  ): Promise<{ data: { message: string }; error: null } | { data: null; error: StorageError }> {\n    try {\n      const result = await this.copyFile({\n        fileList: [\n          {\n            srcPath: this._getCloudPath(fromPath),\n            dstPath: this._getCloudPath(toPath),\n            overwrite: true,\n            removeOriginal: true,\n          },\n        ],\n      })\n\n      if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {\n        throw new StorageError(result.fileList[0].message || 'Move failed')\n      }\n\n      return {\n        data: { message: `File moved from ${fromPath} to ${toPath}` },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async copy(\n    fromPath: string,\n    toPath: string,\n    // options?: DestinationOptions,\n  ): Promise<{ data: { path: string }; error: null } | { data: null; error: StorageError }> {\n    try {\n      const result = await this.copyFile({\n        fileList: [\n          {\n            srcPath: this._getCloudPath(fromPath),\n            dstPath: this._getCloudPath(toPath),\n            overwrite: true,\n            removeOriginal: false,\n          },\n        ],\n      })\n\n      if (result.fileList[0].code && result.fileList[0].code !== 'SUCCESS') {\n        throw new StorageError(result.fileList[0].message || 'Copy failed')\n      }\n\n      return {\n        data: { path: this._getCloudPath(toPath) },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return { data: null, error }\n      }\n      throw error\n    }\n  }\n\n  async createSignedUrl(\n    path: string,\n    expiresIn: number,\n    options?: {\n      download?: string | boolean\n      transform?: TransformOptions\n    },\n  ): Promise<{ data: { signedUrl: string }; error: null } | { data: null; error: StorageError }> {\n    try {\n      const cloudPath = this._normalizeCloudId(path)\n      const result = await this.getTempFileURL({\n        fileList: [\n          {\n            fileID: cloudPath,\n            maxAge: expiresIn,\n          },\n        ],\n      })\n\n      // IGetFileUrlItem 有 code 字段但没有 message 字段\n      if (result.fileList[0].code !== 'SUCCESS') {\n        throw new StorageError(`Failed to create signed URL: [${result.fileList[0].code}] ${result.fileList[0].fileID}`)\n      }\n\n      let signedUrl = result.fileList[0].download_url\n\n      // 构建查询参数\n      const queryParams: string[] = []\n\n      // 如果有 download 参数，添加到 URL 中\n      if (options?.download !== undefined) {\n        if (typeof options.download === 'string') {\n          // download 是文件名\n          queryParams.push(`download=${encodeURIComponent(options.download)}`)\n        } else if (options.download === true) {\n          // download 是 true，使用原文件名或默认值\n          queryParams.push('download=true')\n        }\n      }\n\n      // 如果有图片转换参数，添加到 URL 中\n      if (options?.transform) {\n        const transformQuery = this._transformOptsToQueryString(options.transform)\n        if (transformQuery) {\n          queryParams.push(transformQuery)\n        }\n      }\n\n      // 拼接所有查询参数\n      if (queryParams.length > 0) {\n        const separator = signedUrl.includes('?') ? '&' : '?'\n        signedUrl = `${signedUrl}${separator}${queryParams.join('&')}`\n      }\n\n      return {\n        data: { signedUrl },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async createSignedUrls(\n    paths: string[],\n    expiresIn: number,\n    // options?: {\n    //   download?: string | boolean\n    // },\n  ): Promise<\n    | { data: Array<{ path: string; signedUrl: string; error: string | null }>; error: null }\n    | { data: null; error: StorageError }\n    > {\n    try {\n      const fileList = paths.map(p => ({\n        fileID: this._normalizeCloudId(p),\n        maxAge: expiresIn,\n      }))\n\n      const result = await this.getTempFileURL({ fileList })\n\n      return {\n        data: result.fileList.map((item: any, index: number) => ({\n          path: paths[index],\n          signedUrl: item.tempFileURL || '',\n          error: item.code === 'SUCCESS' ? null : item.message,\n        })),\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async download(\n    path: string,\n    options?: TransformOptions,\n  ): Promise<{\n      data: Blob\n      error: StorageError | null\n    }> {\n    try {\n      return {\n        data: await (async () => {\n          const signedUrlResult = await this.createSignedUrl(path, 600, { transform: options })\n          if (signedUrlResult.error) {\n            throw signedUrlResult.error\n          }\n          const tmpUrl = encodeURI(signedUrlResult.data?.signedUrl)\n\n          const { data } = await (this as any).request.reqClass.get({\n            url: tmpUrl,\n            headers: {}, // 下载资源请求不经过service，header清空\n            responseType: 'blob',\n          })\n\n          if (!data) {\n            throw new StorageError('Download failed: no file content')\n          }\n\n          // 将 Buffer 转换为 Uint8Array 以兼容 Blob\n          return new Blob([data])\n        })(),\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  /**\n   * 获取文件信息\n   *\n   * @param pathOrFileId - 相对路径（如 'images/photo.jpg'）或 CloudBase fileID（以 'cloud://' 开头）\n   * @returns 文件信息对象\n   *\n   * @example\n   * ```typescript\n   * // 使用相对路径\n   * const { data } = await bucket.info('images/photo.jpg')\n   *\n   * // 使用 CloudBase fileID\n   * const { data } = await bucket.info('cloud://env-id.xxxx-xxxx/images/photo.jpg')\n   * ```\n   */\n  async info(pathOrFileId: string,): Promise<{ data: Camelize<FileObjectV2>; error: null } | { data: null; error: StorageError }> {\n    try {\n      // 判断是 fileID 还是相对路径\n      const isFileId = pathOrFileId.startsWith('cloud://')\n      const displayName = isFileId ? this._extractPathFromFileId(pathOrFileId) : pathOrFileId\n      const bucketId = isFileId ? this._extractBucketFromFileId(pathOrFileId) : this.bucketId\n\n      const fileInfo = await this.getFileInfo({\n        fileList: [this._normalizeCloudId(pathOrFileId)],\n      })\n\n      const item = fileInfo.fileList[0]\n\n      if (item.code !== 'SUCCESS') {\n        throw new StorageError(item.message)\n      }\n\n      const now = new Date().toISOString()\n      const lastModified = (item.lastModified ? new Date(item.lastModified) : new Date()).toISOString()\n      return {\n        data: {\n          id: item.fileID,\n          version: '1',\n          name: displayName,\n          bucketId,\n          updatedAt: lastModified,\n          createdAt: lastModified,\n          lastAccessedAt: now,\n          size: item.size,\n          cacheControl: item.cacheControl,\n          contentType: item.contentType,\n          etag: item.etag,\n          lastModified,\n          metadata: {},\n        },\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      return {\n        data: null,\n        error: error instanceof StorageError ? error : new StorageError(error.message),\n      }\n    }\n  }\n\n  async exists(pathOrFileId: string): Promise<{ data: boolean; error: null } | { data: null; error: StorageError }> {\n    try {\n      // 判断是 fileID 还是相对路径\n      const fileInfo = await this.getFileInfo({\n        fileList: [this._normalizeCloudId(pathOrFileId)],\n      })\n\n      const item = fileInfo.fileList[0]\n\n      if (item.code === 'FILE_NOT_FOUND') {\n        return {\n          data: false,\n          error: null,\n        }\n      }\n\n      if (item.code !== 'SUCCESS') {\n        throw new StorageError(item.message)\n      }\n\n      return { data: true, error: null }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      throw error\n    }\n  }\n\n  async getPublicUrl(\n    path: string,\n    options?: {\n      download?: string | boolean\n      transform?: TransformOptions\n    },\n  ): Promise<\n    | {\n      data: { publicUrl: string }\n    }\n    | { data: null; error: StorageError }\n    > {\n    const res = await this.createSignedUrl(path, 600, options)\n\n    if (res.data) {\n      return {\n        data: { publicUrl: res.data.signedUrl },\n      }\n    }\n\n    return { data: null, error: res.error as StorageError }\n  }\n\n  async remove(paths: string[]): Promise<{ data: FileObject[]; error: null } | { data: null; error: StorageError }> {\n    try {\n      // 分组获取文件信息，每组最多10个\n      const chunkSize = 10\n      const pathChunks: string[][] = []\n      for (let i = 0; i < paths.length; i += chunkSize) {\n        pathChunks.push(paths.slice(i, i + chunkSize))\n      }\n\n      // 并行获取所有分组的文件信息\n      const fileInfoResults = await Promise.all(pathChunks.map(chunk => Promise.all(chunk.map(path => this.info(path)))),)\n\n      // 合并所有文件信息并构建映射表（path -> fileInfo）\n      const fileInfoMap = new Map<string, Camelize<FileObjectV2>>()\n      fileInfoResults.flat().forEach((result, index) => {\n        if (result.data) {\n          fileInfoMap.set(paths[Math.floor(index / chunkSize) * chunkSize + (index % chunkSize)], result.data)\n        }\n      })\n\n      // 执行删除操作\n      const fileList = paths.map(p => this._normalizeCloudId(p))\n      const result = await this.deleteFile({ fileList })\n\n      // IDeleteFileRes 的 fileList 数组中每个项有 code 字段\n      const failedFiles = result.fileList.filter(item => item.code !== 'SUCCESS')\n      if (failedFiles.length > 0) {\n        throw new StorageError(`Delete failed for ${failedFiles.length} file(s)`)\n      }\n\n      const now = new Date().toISOString()\n\n      // 使用获取到的文件信息构建返回数据\n      return {\n        data: paths.map((p) => {\n          const info = fileInfoMap.get(p)\n\n          return {\n            name: info?.name,\n            id: info?.id,\n            bucket_id: info?.bucketId,\n            owner: undefined, // 无法计算owner\n            updated_at: info?.updatedAt || now,\n            created_at: info?.createdAt,\n            last_accessed_at: info?.lastAccessedAt || now,\n            metadata: info?.metadata || {},\n            /**\n             * TODO: 获取补全 Bucket 信息\n             */\n            buckets: {\n              id: info?.bucketId,\n              name: info?.bucketId,\n              owner: undefined, // 无法计算owner\n              public: false, // 未知\n              created_at: '', // 未知\n              updated_at: now, // 未知\n            },\n          }\n        }),\n        error: null,\n      }\n    } catch (error: any) {\n      if (this.shouldThrowOnError) throw error\n      if (isStorageError(error)) {\n        return {\n          data: null,\n          error,\n        }\n      }\n      throw error\n    }\n  }\n\n  async list() {\n    throw new StorageError('Not implemented')\n  }\n\n  private _getCloudPath(path: string): string {\n    // 清理路径：移除首尾斜杠，合并多个斜杠\n    const cleanPath = path.replace(/^\\/|\\/$/g, '').replace(/\\/+/g, '/')\n\n    // 否则返回清理后的相对路径\n    return cleanPath\n  }\n\n  private _normalizeCloudId(path: string) {\n    // 如果已经是 cloud:// 格式，直接返回\n    if (/^cloud:\\/\\//.test(path)) {\n      return path\n    }\n    const cleanPath = this._getCloudPath(path)\n\n    // 如果设置了 bucketId，构建完整的 cloud:// 路径\n    if (this.bucketId) {\n      // 获取环境 ID\n      const envId = this.config?.env || ''\n      if (envId) {\n        return `cloud://${envId}.${this.bucketId}/${cleanPath}`\n      }\n    } else {\n      throw new StorageError('bucketId is not set')\n    }\n  }\n\n  private toBase64(data: string) {\n    if (typeof Buffer !== 'undefined') {\n      return Buffer.from(data).toString('base64')\n    }\n    return btoa(data)\n  }\n\n  /**\n   * 将 TransformOptions 转换为腾讯云数据万象的 imageMogr2 查询字符串\n   *\n   * 腾讯云数据万象使用 imageMogr2 接口进行图片处理，支持以下参数：\n   * - /thumbnail/<Width>x<Height> - 缩放\n   * - /format/<Format> - 格式转换\n   * - /quality/<Quality> - 质量调整\n   * - /rquality/<Quality> - 相对质量\n   *\n   * @param transform - Supabase TransformOptions\n   * @returns 腾讯云数据万象的查询字符串\n   *\n   * @example\n   * ```typescript\n   * _transformOptsToQueryString({ width: 300, height: 200, quality: 80, format: 'origin' })\n   * // 返回: 'imageMogr2/thumbnail/300x200/quality/80'\n   * ```\n   */\n  private _transformOptsToQueryString(transform: TransformOptions): string {\n    const params: string[] = ['imageMogr2']\n\n    // 处理缩放参数\n    if (transform.width || transform.height) {\n      const width = transform.width || ''\n      const height = transform.height || ''\n\n      // 根据 resize 模式选择不同的缩放方式\n      if (transform.resize === 'fill') {\n        // fill: 强制缩放到指定尺寸，可能变形\n        params.push(`thumbnail/${width}x${height}!`)\n      } else if (transform.resize === 'contain') {\n        // contain: 等比缩放，完整显示在指定尺寸内\n        params.push(`thumbnail/${width}x${height}`)\n      } else {\n        // cover (默认): 等比缩放，填充指定尺寸，可能裁剪\n        // 使用 /thumbnail/<Width>x<Height>^ 表示填充模式\n        params.push(`thumbnail/${width}x${height}^`)\n      }\n    }\n\n    // 处理格式转换\n    // format: 'origin' 表示保持原格式，不传此参数\n    if (transform.format && transform.format !== 'origin') {\n      params.push(`format/${transform.format}`)\n    }\n\n    // 处理质量参数\n    if (transform.quality !== undefined) {\n      // 腾讯云数据万象的 quality 参数范围是 1-100\n      const quality = Math.max(1, Math.min(100, transform.quality))\n      params.push(`quality/${quality}`)\n    }\n\n    return params.join('/')\n  }\n\n  /**\n   * 从 CloudBase fileID 中提取文件路径\n   *\n   * @param fileId - CloudBase fileID (格式: cloud://env-id.bucket/path/to/file.jpg)\n   * @returns 提取的文件路径\n   *\n   * @example\n   * ```typescript\n   * _extractPathFromFileId('cloud://test-env.test-bucket/images/photo.jpg')\n   * // 返回: 'images/photo.jpg'\n   *\n   * _extractPathFromFileId('cloud://test-env.test-bucket/file.txt')\n   * // 返回: 'file.txt'\n   * ```\n   */\n  private _extractPathFromFileId(fileId: string): string {\n    // fileID 格式: cloud://env-id.bucket/path/to/file.jpg\n    // 需要提取第一个 / 后面的所有内容（包括 bucket 和路径）\n    // 然后再提取 bucket 后面的路径部分\n\n    // 移除 cloud:// 前缀\n    const withoutProtocol = fileId.replace(/^cloud:\\/\\//, '')\n\n    // 分割为 [env-id.bucket, path, to, file.jpg]\n    const parts = withoutProtocol.split('/')\n\n    if (parts.length < 2) {\n      // 如果无法解析，返回完整的 fileID\n      return fileId\n    }\n\n    // 移除第一部分（env-id.bucket），返回剩余路径\n    return parts.slice(1).join('/')\n  }\n\n  /**\n   * 从 CloudBase fileID 中提取 bucket 名称\n   *\n   * @param fileId - CloudBase fileID (格式: cloud://env-id.bucket/path/to/file.jpg)\n   * @returns 提取的 bucket 名称\n   *\n   * @example\n   * ```typescript\n   * _extractBucketFromFileId('cloud://test-env.test-bucket/images/photo.jpg')\n   * // 返回: 'test-bucket'\n   *\n   * _extractBucketFromFileId('cloud://prod-env.my-bucket/file.txt')\n   * // 返回: 'my-bucket'\n   * ```\n   */\n  private _extractBucketFromFileId(fileId: string): string {\n    // fileID 格式: cloud://env-id.bucket/path/to/file.jpg\n    // 需要提取 env-id.bucket 中的 bucket 部分\n\n    // 移除 cloud:// 前缀\n    const withoutProtocol = fileId.replace(/^cloud:\\/\\//, '')\n\n    // 分割为 [env-id.bucket, path, to, file.jpg]\n    const parts = withoutProtocol.split('/')\n\n    if (parts.length < 1) {\n      // 如果无法解析，返回默认 bucket\n      return ''\n    }\n\n    // 第一部分是 env-id.bucket，提取 bucket 部分\n    // 格式: env-id.bucket 或 env-id.bucket-name\n    const envAndBucket = parts[0]\n\n    // 查找第一个点的位置\n    const dotIndex = envAndBucket.indexOf('.')\n\n    if (dotIndex === -1) {\n      // 如果没有点，返回整个字符串\n      return envAndBucket\n    }\n\n    // 返回点后面的部分（bucket 名称）\n    return envAndBucket.substring(dotIndex + 1)\n  }\n}\n\nconst supabaseComponent: ICloudbaseComponent = {\n  name: `${COMPONENT_NAME}/supabase`,\n  IIFE: true,\n  entity() {\n    // 在 IIFE 中，this 是 Cloudbase 类（构造函数），不是实例\n    // 所以我们需要使用 getter 来延迟获取实例的 config 和 request\n\n    // 使用 WeakMap 缓存每个实例的 storage 对象\n    const storageCache = new WeakMap<any, SupabaseFileAPILikeStorage>()\n\n    // 定义 storage 属性的 getter，每个实例只创建一次\n    Object.defineProperty(this.prototype, 'storage', {\n      get() {\n        // 这里的 this 是 cloudbase 实例\n\n        // 如果已经创建过，直接返回缓存的实例\n        if (storageCache.has(this)) {\n          return storageCache.get(this)\n        }\n\n        // 创建动态 context，从当前实例获取 config 和 request\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const instance = this\n        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n        const context = new Proxy<ICloudbaseContext>({} as ICloudbaseContext, {\n          get: (_target, prop) => {\n            if (prop === 'config') {\n              return instance.config\n            }\n            if (prop === 'request') {\n              return instance.request\n            }\n            return undefined\n          },\n        })\n\n        // 创建新的 storage 实例并缓存\n        const storage = new SupabaseFileAPILikeStorage(context)\n        storageCache.set(this, storage)\n        return storage\n      },\n      configurable: true,\n      enumerable: true,\n    })\n  },\n}\n\ntry {\n  cloudbase.registerComponent(component)\n  cloudbase.registerComponent(supabaseComponent)\n} catch (e) {}\n\nexport function registerStorage(app: Pick<ICloudbase, 'registerComponent'>) {\n  try {\n    app.registerComponent(component)\n    app.registerComponent(supabaseComponent)\n  } catch (e) {\n    console.warn(e)\n  }\n}\n\ntry {\n  (window as any).registerStorage = registerStorage\n} catch (e) {}\n"]}