@cloudbase/auth 2.26.1 → 2.26.3

package/dist/cjs/v1-compat.js

@@ -0,0 +1,423 @@
+"use strict";
+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 __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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyUserV1Compat = exports.AuthV1Compat = exports.AnonymousAuthProvider = exports.CustomAuthProvider = exports.WeixinAuthProvider = void 0;
+var oauth_1 = require("@cloudbase/oauth");
+var utilities_1 = require("./utilities");
+var WeixinAuthProvider = (function () {
+    function WeixinAuthProvider(_options) {
+    }
+    WeixinAuthProvider.prototype.signInWithRedirect = function () {
+        throw new Error('[v1 兼容] WeixinAuthProvider.signInWithRedirect() 在当前版本中无法实现。'
+            + ' 建议使用 auth.signInWithOAuth({ provider: \'providerId\' }) 替代。');
+    };
+    WeixinAuthProvider.prototype.getRedirectResult = function (_options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('[v1 兼容] WeixinAuthProvider.getRedirectResult() 在当前版本中无法实现。'
+                    + ' 建议使用 auth.verifyOAuth({ code, state, provider }) 替代。');
+            });
+        });
+    };
+    WeixinAuthProvider.prototype.getLinkRedirectResult = function (_options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('[v1 兼容] WeixinAuthProvider.getLinkRedirectResult() 在当前版本中无法实现。'
+                    + ' 建议使用 auth.linkIdentity({ provider: \'providerId\' }) 替代。');
+            });
+        });
+    };
+    return WeixinAuthProvider;
+}());
+exports.WeixinAuthProvider = WeixinAuthProvider;
+var CustomAuthProvider = (function () {
+    function CustomAuthProvider(options) {
+        this.authInstance = options.authInstance;
+    }
+    CustomAuthProvider.prototype.signIn = function (ticket) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.authInstance.signInWithCustomTicket(function () { return Promise.resolve(ticket); })];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    return CustomAuthProvider;
+}());
+exports.CustomAuthProvider = CustomAuthProvider;
+var AnonymousAuthProvider = (function () {
+    function AnonymousAuthProvider(options) {
+        this.authInstance = options.authInstance;
+    }
+    AnonymousAuthProvider.prototype.signIn = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.authInstance.signInAnonymously({})];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    return AnonymousAuthProvider;
+}());
+exports.AnonymousAuthProvider = AnonymousAuthProvider;
+var AuthV1Compat = (function () {
+    function AuthV1Compat() {
+    }
+    AuthV1Compat.prototype.weixinAuthProvider = function (options) {
+        return new WeixinAuthProvider({
+            authInstance: this,
+            appid: options.appid,
+            scope: options.scope,
+        });
+    };
+    AuthV1Compat.prototype.customAuthProvider = function () {
+        return new CustomAuthProvider({
+            authInstance: this,
+        });
+    };
+    AuthV1Compat.prototype.anonymousAuthProvider = function () {
+        return new AnonymousAuthProvider({
+            authInstance: this,
+        });
+    };
+    AuthV1Compat.prototype.signUpWithEmailAndPassword = function (email, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof email !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'email must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'password must be a string');
+                        }
+                        return [4, this.signUp({
+                                email: email,
+                                password: password,
+                            })];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.signInWithEmailAndPassword = function (email, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof email !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'email must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'password must be a string');
+                        }
+                        return [4, this.signIn({
+                                username: email,
+                                password: password,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2, this.createLoginState()];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.sendPasswordResetEmail = function (email) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof email !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'email must be a string');
+                        }
+                        return [4, this.getVerification({ email: email })];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.signInWithUsernameAndPassword = function (username, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof username !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'username must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'password must be a string');
+                        }
+                        return [4, this.signIn({
+                                username: username,
+                                password: password,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2, this.createLoginState()];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.sendPhoneCode = function (phoneNumber) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedPhone;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof phoneNumber !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
+                        }
+                        formattedPhone = this.formatPhone(phoneNumber);
+                        return [4, this.getVerification({ phone_number: formattedPhone })];
+                    case 1:
+                        _a.sent();
+                        return [2, true];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.signUpWithPhoneCode = function (phoneNumber, phoneCode, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedPhone;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof phoneNumber !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
+                        }
+                        if (typeof phoneCode !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneCode must be a string');
+                        }
+                        formattedPhone = this.formatPhone(phoneNumber);
+                        return [4, this.signUp(__assign({ phone_number: formattedPhone, verification_code: phoneCode }, (password ? { password: password } : {})))];
+                    case 1:
+                        _a.sent();
+                        return [2, this.createLoginState()];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.signInWithPhoneCodeOrPassword = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var phoneNumber, phoneCode, password, formattedPhone;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        phoneNumber = params.phoneNumber, phoneCode = params.phoneCode, password = params.password;
+                        if (typeof phoneNumber !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
+                        }
+                        formattedPhone = this.formatPhone(phoneNumber);
+                        if (!password) return [3, 2];
+                        return [4, this.signIn({
+                                username: formattedPhone,
+                                password: password,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [3, 5];
+                    case 2:
+                        if (!phoneCode) return [3, 4];
+                        return [4, this.signIn({
+                                username: formattedPhone,
+                                verification_token: phoneCode,
+                            })];
+                    case 3:
+                        _a.sent();
+                        return [3, 5];
+                    case 4:
+                        (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneCode or password must be provided');
+                        _a.label = 5;
+                    case 5: return [2, this.createLoginState()];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.forceResetPwdByPhoneCode = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var phoneNumber, phoneCode, password, formattedPhone;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        phoneNumber = params.phoneNumber, phoneCode = params.phoneCode, password = params.password;
+                        if (typeof phoneNumber !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
+                        }
+                        if (typeof phoneCode !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'phoneCode must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'password must be a string');
+                        }
+                        formattedPhone = this.formatPhone(phoneNumber);
+                        return [4, this.resetPassword({
+                                phone_number: formattedPhone,
+                                new_password: password,
+                                verification_token: phoneCode,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [4, this.signIn({
+                                username: formattedPhone,
+                                password: password,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2, this.createLoginState()];
+                }
+            });
+        });
+    };
+    AuthV1Compat.prototype.shouldRefreshAccessToken = function (_callback) {
+        throw new Error('[v1 兼容] shouldRefreshAccessToken() 在当前版本中无法实现。'
+            + ' 建议使用 auth.onAuthStateChange(callback) 来监听 TOKEN_REFRESHED 事件替代。');
+    };
+    AuthV1Compat.prototype.onLoginStateExpired = function (callback) {
+        var _this = this;
+        this.onLoginStateChanged(function (params) {
+            if ((params === null || params === void 0 ? void 0 : params.eventType) === oauth_1.LOGIN_STATE_CHANGED_TYPE.CREDENTIALS_ERROR) {
+                callback.call(_this);
+            }
+        });
+    };
+    AuthV1Compat.prototype.onAccessTokenRefreshed = function (callback) {
+        var _this = this;
+        this.onAuthStateChange(function (event) {
+            if (event === oauth_1.AUTH_STATE_CHANGED_TYPE.TOKEN_REFRESHED) {
+                callback.call(_this);
+            }
+        });
+    };
+    AuthV1Compat.prototype.onAnonymousConverted = function (callback) {
+        var _this = this;
+        this.onAuthStateChange(function (event) {
+            if (event === oauth_1.AUTH_STATE_CHANGED_TYPE.SIGNED_IN) {
+                callback.call(_this);
+            }
+        });
+    };
+    AuthV1Compat.prototype.onLoginTypeChanged = function (callback) {
+        var _this = this;
+        this.onAuthStateChange(function (event) {
+            if (event === oauth_1.AUTH_STATE_CHANGED_TYPE.SIGNED_IN || event === oauth_1.AUTH_STATE_CHANGED_TYPE.SIGNED_OUT) {
+                callback.call(_this);
+            }
+        });
+    };
+    return AuthV1Compat;
+}());
+exports.AuthV1Compat = AuthV1Compat;
+function applyUserV1Compat(UserClass) {
+    UserClass.prototype.linkWithTicket = function (_ticket) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('[v1 兼容] User.linkWithTicket() 在当前版本中无法实现。'
+                    + ' 建议使用 auth.signInWithCustomTicket(() => Promise.resolve(ticket)) 替代。');
+            });
+        });
+    };
+    UserClass.prototype.linkWithRedirect = function (_provider) {
+        throw new Error('[v1 兼容] User.linkWithRedirect() 在当前版本中无法实现。'
+            + ' 建议使用 auth.linkIdentity({ provider: \'providerId\' }) 替代。');
+    };
+    UserClass.prototype.updateEmail = function (newEmail, _password) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof newEmail !== 'string') {
+                            (0, utilities_1.throwError)(utilities_1.ERRORS.INVALID_PARAMS, 'newEmail must be a string');
+                        }
+                        return [4, this.updateUserBasicInfo({
+                                email: newEmail,
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    UserClass.prototype.linkWithPhoneNumber = function (_phoneNumber, _phoneCode) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('[v1 兼容] User.linkWithPhoneNumber() 在当前版本中无法实现。'
+                    + ' 建议使用 auth.bindPhoneNumber({ phone_number, verification_token, sudo_token }) 替代。');
+            });
+        });
+    };
+    UserClass.prototype.updatePhoneNumber = function (_phoneNumber, _phoneCode) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('[v1 兼容] User.updatePhoneNumber() 在当前版本中无法实现。'
+                    + ' 建议使用 auth.updateUser({ phone: newPhoneNumber }) 替代。');
+            });
+        });
+    };
+    UserClass.prototype.unlink = function (_loginType) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('[v1 兼容] User.unlink() 在当前版本中无法实现。'
+                    + ' 建议使用 auth.unlinkIdentity({ provider: loginType }) 替代。');
+            });
+        });
+    };
+}
+exports.applyUserV1Compat = applyUserV1Compat;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v1-compat.js","sourceRoot":"","sources":["../../src/v1-compat.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-useless-constructor */\n/**\n * v1 兼容层\n * 本文件包含 v1 版本的 Provider 类、Auth v1 兼容方法和 User v1 兼容方法。\n * Auth 类通过 extends AuthV1Compat 来继承 v1 方法。\n * User 类通过 applyUserV1Compat mixin 来扩展 v1 方法。\n */\nimport type { authModels } from '@cloudbase/oauth'\nimport {\n  LOGIN_STATE_CHANGED_TYPE,\n  AUTH_STATE_CHANGED_TYPE,\n} from '@cloudbase/oauth'\nimport {\n  throwError,\n  ERRORS,\n} from './utilities'\nimport type { SignUpRes } from './type'\n\n// ========== v1 兼容 Provider 类 ==========\n\n/**\n * v1 微信登录 Provider\n * 使用方式: auth.weixinAuthProvider({ appid, scope }).signInWithRedirect()\n *\n * @deprecated v1 兼容 API。建议使用 auth.signInWithOAuth({ provider }) 替代。\n */\nexport class WeixinAuthProvider {\n  constructor(_options: {\n    authInstance: any\n    appid: string\n    scope: string\n  }) {\n    // v1 兼容类，所有方法均抛出异常提示替代方案\n  }\n\n  /**\n   * @deprecated v1 兼容 API。\n   * 建议使用 auth.signInWithOAuth({ provider: 'providerId' }) 替代。\n   */\n  public signInWithRedirect(): void {\n    throw new Error('[v1 兼容] WeixinAuthProvider.signInWithRedirect() 在当前版本中无法实现。'\n      + ' 建议使用 auth.signInWithOAuth({ provider: \\'providerId\\' }) 替代。',)\n  }\n\n  /**\n   * @deprecated v1 兼容 API。\n   * 建议使用 auth.verifyOAuth({ code, state, provider }) 替代。\n   */\n  public async getRedirectResult(_options?: {\n    createUser?: boolean\n    syncUserInfo?: boolean\n  }): Promise<any> {\n    throw new Error('[v1 兼容] WeixinAuthProvider.getRedirectResult() 在当前版本中无法实现。'\n      + ' 建议使用 auth.verifyOAuth({ code, state, provider }) 替代。',)\n  }\n\n  /**\n   * @deprecated v1 兼容 API。\n   * 建议使用 auth.linkIdentity({ provider: 'providerId' }) 替代。\n   */\n  public async getLinkRedirectResult(_options?: {\n    withUnionId?: boolean\n  }): Promise<void> {\n    throw new Error('[v1 兼容] WeixinAuthProvider.getLinkRedirectResult() 在当前版本中无法实现。'\n      + ' 建议使用 auth.linkIdentity({ provider: \\'providerId\\' }) 替代。',)\n  }\n}\n\n/**\n * v1 自定义登录 Provider\n * 使用方式: auth.customAuthProvider().signIn(ticket)\n *\n * @deprecated v1 兼容 API。建议使用 auth.signInWithCustomTicket(() => Promise.resolve(ticket)) 替代。\n */\nexport class CustomAuthProvider {\n  private authInstance: any\n\n  constructor(options: {\n    authInstance: any\n  }) {\n    this.authInstance = options.authInstance\n  }\n\n  /**\n   * 使用自定义登录凭据 ticket 登录云开发\n   * @param ticket 自定义登录 ticket\n   * @deprecated v1 兼容 API。建议使用 auth.signInWithCustomTicket(() => Promise.resolve(ticket)) 替代。\n   */\n  public async signIn(ticket: string): Promise<void> {\n    // 使用 Auth 已有的 signInWithCustomTicket 方法\n    await this.authInstance.signInWithCustomTicket(() => Promise.resolve(ticket))\n  }\n}\n\n/**\n * v1 匿名登录 Provider\n * 使用方式: auth.anonymousAuthProvider().signIn()\n *\n * @deprecated v1 兼容 API。建议使用 auth.signInAnonymously({}) 替代。\n */\nexport class AnonymousAuthProvider {\n  private authInstance: any\n\n  constructor(options: {\n    authInstance: any\n  }) {\n    this.authInstance = options.authInstance\n  }\n\n  /**\n   * 匿名登录云开发\n   * @deprecated v1 兼容 API。建议使用 auth.signInAnonymously({}) 替代。\n   */\n  public async signIn(): Promise<void> {\n    // 使用 Auth 已有的 signInAnonymously 方法\n    await this.authInstance.signInAnonymously({})\n  }\n}\n\n// ========== Auth v1 兼容基类 ==========\n\n/**\n * AuthV1Compat 基类，提供 v1 版本的兼容 API 方法。\n * Auth 类通过 extends AuthV1Compat 来继承这些方法。\n *\n * 注意：此类中的方法通过 this 访问子类 Auth 的方法和属性，\n * 包括: signIn, signUp, signInWithCustomTicket, signInAnonymously,\n * getVerification, resetPassword, onLoginStateChanged, onAuthStateChange,\n * createLoginState, formatPhone, config, signInWithOAuth 等。\n */\n// eslint-disable @typescript-eslint/member-ordering -- abstract 基类中 abstract 声明与 public 方法排序不适用常规规则\nexport abstract class AuthV1Compat {\n  abstract readonly config: any\n\n  // ========== v1 兼容 API 方法 ==========\n\n  /**\n   * v1 API: 获取用于微信登录的 WeixinAuthProvider // cspell:ignore weixin Weixin\n   * @deprecated 建议使用 auth.signInWithOAuth({ provider: appid }) 替代。\n   */\n  public weixinAuthProvider(options: { appid: string; scope: string }): WeixinAuthProvider {\n    return new WeixinAuthProvider({\n      authInstance: this,\n      appid: options.appid,\n      scope: options.scope,\n    })\n  }\n\n  /**\n   * v1 API: 获取用于自定义登录的 CustomAuthProvider\n   * @deprecated 建议使用 auth.signInWithCustomTicket(() => Promise.resolve(ticket)) 替代。\n   */\n  public customAuthProvider(): CustomAuthProvider {\n    return new CustomAuthProvider({\n      authInstance: this,\n    })\n  }\n\n  /**\n   * v1 API: 获取用于匿名登录的 AnonymousAuthProvider\n   * @deprecated 建议使用 auth.signInAnonymously({}) 替代。\n   */\n  public anonymousAuthProvider(): AnonymousAuthProvider {\n    return new AnonymousAuthProvider({\n      authInstance: this,\n    })\n  }\n\n  /**\n   * v1 API: 使用邮箱和密码注册云开发账户\n   * @deprecated 建议使用 auth.signUp({ email, password }) 替代。\n   */\n  public async signUpWithEmailAndPassword(email: string, password: string): Promise<SignUpRes> {\n    if (typeof email !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'email must be a string')\n    }\n    if (typeof password !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'password must be a string')\n    }\n\n    // 使用 Auth 已有的 signUp 方法\n    return await this.signUp({\n      email,\n      password,\n    })\n  }\n\n  /**\n   * v1 API: 使用邮箱和密码登录云开发\n   * @deprecated 建议使用 auth.signInWithPassword({ email, password }) 替代。\n   */\n  public async signInWithEmailAndPassword(email: string, password: string): Promise<any> {\n    if (typeof email !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'email must be a string')\n    }\n    if (typeof password !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'password must be a string')\n    }\n\n    // 使用 Auth 已有的 signIn 方法\n    await this.signIn({\n      username: email,\n      password,\n    })\n    return this.createLoginState()\n  }\n\n  /**\n   * v1 API: 发送重置密码的邮件\n   * @deprecated 建议使用 auth.resetPasswordForEmail(email) 替代。\n   */\n  public async sendPasswordResetEmail(email: string): Promise<void> {\n    if (typeof email !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'email must be a string')\n    }\n\n    // 使用 Auth 已有的 getVerification 方法\n    await this.getVerification({ email })\n  }\n\n  /**\n   * v1 API: 使用用户名密码登录云开发\n   * @deprecated 建议使用 auth.signInWithPassword({ username, password }) 替代。\n   */\n  public async signInWithUsernameAndPassword(username: string, password: string): Promise<any> {\n    if (typeof username !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'username must be a string')\n    }\n    if (typeof password !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'password must be a string')\n    }\n\n    // 使用 Auth 已有的 signIn 方法\n    await this.signIn({\n      username,\n      password,\n    })\n    return this.createLoginState()\n  }\n\n  /**\n   * v1 API: 发送手机验证码\n   * @deprecated 建议使用 auth.signInWithOtp({ phone }) 或 auth.getVerification({ phone_number }) 替代。\n   */\n  public async sendPhoneCode(phoneNumber: string): Promise<boolean> {\n    if (typeof phoneNumber !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string')\n    }\n\n    // 使用 Auth 已有的 getVerification 方法\n    const formattedPhone = this.formatPhone(phoneNumber)\n    await this.getVerification({ phone_number: formattedPhone })\n    return true\n  }\n\n  /**\n   * v1 API: 手机号注册（支持短信验证码+密码方式）\n   * @deprecated 建议使用 auth.signUp({ phone_number, verification_code, password? }) 替代。\n   */\n  public async signUpWithPhoneCode(phoneNumber: string, phoneCode: string, password?: string): Promise<any> {\n    if (typeof phoneNumber !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string')\n    }\n    if (typeof phoneCode !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneCode must be a string')\n    }\n\n    const formattedPhone = this.formatPhone(phoneNumber)\n\n    // 使用 Auth 已有的 signUp 方法\n    await this.signUp({\n      phone_number: formattedPhone,\n      verification_code: phoneCode,\n      ...(password ? { password } : {}),\n    })\n    return this.createLoginState()\n  }\n\n  /**\n   * v1 API: 手机号登录（支持短信验证码 or 密码方式）\n   * @deprecated 密码方式建议使用 auth.signInWithPassword({ phone, password }) 替代；\n   * 验证码方式建议使用 auth.signInWithOtp({ phone }) 替代。\n   */\n  public async signInWithPhoneCodeOrPassword(params: {\n    phoneNumber: string\n    phoneCode?: string\n    password?: string\n  }): Promise<any> {\n    const { phoneNumber, phoneCode, password } = params\n    if (typeof phoneNumber !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string')\n    }\n\n    const formattedPhone = this.formatPhone(phoneNumber)\n\n    if (password) {\n      // 使用 Auth 已有的 signIn 方法进行密码登录\n      await this.signIn({\n        username: formattedPhone,\n        password,\n      })\n    } else if (phoneCode) {\n      // 使用 Auth 已有的 signIn 方法进行验证码登录\n      await this.signIn({\n        username: formattedPhone,\n        verification_token: phoneCode,\n      } as any)\n    } else {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneCode or password must be provided')\n    }\n    return this.createLoginState()\n  }\n\n  /**\n   * v1 API: 手机号强制重置密码\n   * @deprecated 建议使用 auth.resetPasswordForEmail(phoneNumber) 替代。\n   */\n  public async forceResetPwdByPhoneCode(params: {\n    phoneNumber: string\n    phoneCode: string\n    password: string\n  }): Promise<any> {\n    const { phoneNumber, phoneCode, password } = params\n    if (typeof phoneNumber !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string')\n    }\n    if (typeof phoneCode !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'phoneCode must be a string')\n    }\n    if (typeof password !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'password must be a string')\n    }\n\n    const formattedPhone = this.formatPhone(phoneNumber)\n\n    // 使用 Auth 已有的 resetPassword 方法\n    await this.resetPassword({\n      phone_number: formattedPhone,\n      new_password: password,\n      verification_token: phoneCode,\n    })\n\n    // 重置密码成功后使用 Auth 已有的 signIn 方法自动登录\n    await this.signIn({\n      username: formattedPhone,\n      password,\n    })\n    return this.createLoginState()\n  }\n\n  /**\n   * v1 API: 接收一个回调函数，在刷新短期访问令牌前调用，根据返回值决定是否刷新\n   * @deprecated v1 兼容 API，当前 v3 SDK 中无直接对应方法。\n   * 建议使用 auth.onAuthStateChange(callback) 监听 TOKEN_REFRESHED 事件替代。\n   */\n  public shouldRefreshAccessToken(_callback: () => boolean): void {\n    throw new Error('[v1 兼容] shouldRefreshAccessToken() 在当前版本中无法实现。'\n      + ' 建议使用 auth.onAuthStateChange(callback) 来监听 TOKEN_REFRESHED 事件替代。',)\n  }\n\n  /**\n   * v1 API: 接收一个回调函数，在登录状态过期时调用\n   * @deprecated 建议使用 auth.onAuthStateChange(callback) 替代，监听 SIGNED_OUT 事件。\n   */\n  public onLoginStateExpired(callback: Function): void {\n    // 使用 Auth 已有的 onLoginStateChanged 方法\n    this.onLoginStateChanged((params) => {\n      if (params?.eventType === LOGIN_STATE_CHANGED_TYPE.CREDENTIALS_ERROR) {\n        callback.call(this)\n      }\n    })\n  }\n\n  /**\n   * v1 API: 接收一个回调函数，在短期访问令牌刷新后调用\n   * @deprecated 建议使用 auth.onAuthStateChange(callback) 替代，监听 TOKEN_REFRESHED 事件。\n   */\n  public onAccessTokenRefreshed(callback: Function): void {\n    // 使用 Auth 已有的 onAuthStateChange 方法\n    this.onAuthStateChange((event) => {\n      if (event === AUTH_STATE_CHANGED_TYPE.TOKEN_REFRESHED) {\n        callback.call(this)\n      }\n    })\n  }\n\n  /**\n   * v1 API: 接收一个回调函数，在匿名登录状态被转换后调用\n   * @deprecated 建议使用 auth.onAuthStateChange(callback) 替代，监听 SIGNED_IN 事件。\n   */\n  public onAnonymousConverted(callback: Function): void {\n    // 使用 Auth 已有的 onAuthStateChange 方法\n    this.onAuthStateChange((event) => {\n      if (event === AUTH_STATE_CHANGED_TYPE.SIGNED_IN) {\n        callback.call(this)\n      }\n    })\n  }\n\n  /**\n   * v1 API: 接收一个回调函数，在登录类型发生变化后调用\n   * @deprecated 建议使用 auth.onAuthStateChange(callback) 替代，监听 SIGNED_IN / SIGNED_OUT 事件。\n   */\n  public onLoginTypeChanged(callback: Function): void {\n    // 使用 Auth 已有的 onAuthStateChange 方法\n    this.onAuthStateChange((event) => {\n      if (event === AUTH_STATE_CHANGED_TYPE.SIGNED_IN || event === AUTH_STATE_CHANGED_TYPE.SIGNED_OUT) {\n        callback.call(this)\n      }\n    })\n  }\n\n  // ========== 声明子类 Auth 需要提供的方法/属性 ==========\n  abstract signIn(params: authModels.SignInRequest): Promise<any>\n  abstract signUp(params: authModels.SignUpRequest & { phone?: string }): Promise<SignUpRes>\n  abstract signInWithCustomTicket(getTickFn?: authModels.GetCustomSignTicketFn): Promise<any>\n  abstract signInAnonymously(params: any): Promise<any>\n  abstract getVerification(params: any, options?: any): Promise<authModels.GetVerificationResponse>\n  abstract resetPassword(params: authModels.ResetPasswordRequest): Promise<void>\n  abstract onLoginStateChanged(callback: Function): Promise<void>\n  abstract onAuthStateChange(callback: any): any\n  abstract createLoginState(params?: any, options?: any): Promise<any>\n  abstract signInWithOAuth(params: any): Promise<any>\n  abstract grantProviderToken(params: authModels.GrantProviderTokenRequest): Promise<authModels.GrantProviderTokenResponse>\n  abstract bindWithProvider(params: authModels.BindWithProviderRequest): Promise<void>\n  protected abstract formatPhone(phone: string): string\n}\n\n// ========== User v1 兼容 mixin ==========\n\n/**\n * 将 v1 兼容方法应用到 User 类的 prototype 上。\n * 在 index.ts 中调用: applyUserV1Compat(User)\n */\nexport function applyUserV1Compat(UserClass: any): void {\n  /**\n   * v1 API: 将当前账户与自定义登录 Ticket 进行绑定\n   * @deprecated v1 兼容 API，当前版本中无法直接实现。\n   * 建议使用 auth.signInWithCustomTicket(() => Promise.resolve(ticket)) 替代。\n   */\n  UserClass.prototype.linkWithTicket = async function (_ticket: string): Promise<void> {\n    throw new Error('[v1 兼容] User.linkWithTicket() 在当前版本中无法实现。'\n      + ' 建议使用 auth.signInWithCustomTicket(() => Promise.resolve(ticket)) 替代。',)\n  }\n\n  /**\n   * v1 API: 将当前账户与第三方鉴权提供方（以重定向形式）进行绑定\n   * @deprecated 建议使用 auth.linkIdentity({ provider: 'providerId' }) 替代。\n   */\n  UserClass.prototype.linkWithRedirect = function (_provider: any): void {\n    throw new Error('[v1 兼容] User.linkWithRedirect() 在当前版本中无法实现。'\n      + ' 建议使用 auth.linkIdentity({ provider: \\'providerId\\' }) 替代。',)\n  }\n\n  /**\n   * v1 API: 更新当前的登录邮箱\n   * @deprecated 建议使用 auth.updateUser({ email: newEmail }) 替代。\n   */\n  UserClass.prototype.updateEmail = async function (newEmail: string, _password?: string): Promise<void> {\n    if (typeof newEmail !== 'string') {\n      throwError(ERRORS.INVALID_PARAMS, 'newEmail must be a string')\n    }\n\n    // 使用 User 已有的 updateUserBasicInfo 方法\n    await this.updateUserBasicInfo({\n      email: newEmail,\n    })\n  }\n\n  /**\n   * v1 API: 绑定手机号\n   * @deprecated v1 兼容 API，当前版本中无法直接在 User 上实现。\n   * 建议使用 auth.bindPhoneNumber({ phone_number, verification_token, sudo_token }) 替代。\n   */\n  UserClass.prototype.linkWithPhoneNumber = async function (_phoneNumber: string, _phoneCode: string): Promise<void> {\n    throw new Error('[v1 兼容] User.linkWithPhoneNumber() 在当前版本中无法实现。'\n      + ' 建议使用 auth.bindPhoneNumber({ phone_number, verification_token, sudo_token }) 替代。',)\n  }\n\n  /**\n   * v1 API: 更新手机号\n   * @deprecated v1 兼容 API，当前版本中无法直接在 User 上实现。\n   * 建议使用 auth.updateUser({ phone: newPhoneNumber }) 替代。\n   */\n  UserClass.prototype.updatePhoneNumber = async function (_phoneNumber: string, _phoneCode: string): Promise<void> {\n    throw new Error('[v1 兼容] User.updatePhoneNumber() 在当前版本中无法实现。'\n      + ' 建议使用 auth.updateUser({ phone: newPhoneNumber }) 替代。',)\n  }\n\n  /**\n   * v1 API: 解绑某个登录方式\n   * @deprecated v1 兼容 API，当前版本中无法直接在 User 上实现。\n   * 建议使用 auth.unlinkIdentity({ provider: loginType }) 替代。\n   */\n  UserClass.prototype.unlink = async function (_loginType: string): Promise<void> {\n    throw new Error('[v1 兼容] User.unlink() 在当前版本中无法实现。'\n      + ' 建议使用 auth.unlinkIdentity({ provider: loginType }) 替代。',)\n  }\n}\n"]}

package/dist/esm/adapter.js

@@ -180,6 +180,7 @@ var dealUserAdapter = function (config, adapter) {
             var reqClassParams = {
                 timeout: 10000,
                 restrictedMethods: ['get', 'post', 'upload', 'download', 'request'],
+                auth: config.auth,
             };
             var adapterReq_1 = new adapter.reqClass(reqClassParams);
             data.baseRequest = function (url, options) {
@@ -264,4 +265,4 @@ export var useAuthAdapter = function (config) {
     }
     return dealAuthAdapter(config, config.adapter);
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { SDKAdapterInterface } from '@cloudbase/adapter-interface'\nimport { adapterForWxMp } from './utilities'\nimport type { AuthOptions } from '@cloudbase/oauth'\n\ndeclare const wx: any\n\nclass OauthClientStorageBase {\n  public readonly localStorage\n  constructor(config?: { localStorage: any /* StorageInterface */; adapter: SDKAdapterInterface }) {\n    try {\n      this.localStorage = config?.localStorage || (config?.adapter?.root?.globalThis || globalThis).localStorage\n    } catch (error) {\n      this.localStorage = config?.localStorage || {}\n    }\n  }\n  /**\n   * Get Item\n   * @param {string} key\n   * @return {Promise<string | null>}\n   */\n  async getItem(key: string): Promise<string | null> {\n    return this.localStorage.getItem(key)\n  }\n\n  /**\n   * Remove Item.\n   * @param {string} key\n   * @return {Promise<void>}\n   */\n  async removeItem(key: string) {\n    this.localStorage.removeItem(key)\n  }\n\n  /**\n   * Set Item.\n   * @param {string} key\n   * @param {string} value\n   * @return {Promise<void>}\n   */\n  async setItem(key: string, value: string): Promise<void> {\n    this.localStorage.setItem(key, value)\n  }\n\n  getItemSync(key: string): string | null {\n    return this.localStorage.getItem(key)\n  }\n\n  setItemSync(key: string, value: string) {\n    this.localStorage.setItem(key, value)\n  }\n\n  removeItemSync(key: string) {\n    this.localStorage.removeItem(key)\n  }\n}\n\n/**\n * copy to git@git.woa.com:QBase/lcap/datasource.git/packages/cloud-sdk/common\n * 同步修改\n */\nconst URL_REG = /^[^:]+:\\/\\/[^/]+(\\/[^?#]+)/\n\nconst dealAdapterRequestData = (res, options) => {\n  const requestId = options?.headers?.['x-request-id']\n\n  if (!res) {\n    res = {}\n  }\n\n  if (res?.code || res?.data?.error_code) {\n    res = {\n      error: res.code || res.data.error,\n      error_description: res.data.error_description || res.message || res.code || res.data.error_code,\n      request_id: res.requestId,\n      error_code: res.data?.error_code,\n    }\n  }\n\n  if (!res?.request_id) {\n    res.request_id = res.request_id || requestId\n  }\n\n  if (res?.error) {\n    res.error_uri = getUrlPath(options?.url)\n    return res\n  }\n\n  return res?.data || {}\n}\n\nfunction generateOauthClientRequest(reqClass) {\n  return async function (\n    url: string,\n    options?: {\n      body?: any | null\n      headers?: any | null\n      method?: string\n      [key: string]: any\n    },\n  ) {\n    return new Promise((resolve, reject) => {\n      // Objects must be copied to prevent modification of data such as body.\n      const copyOptions = Object.assign({}, options)\n      if (copyOptions.body && typeof copyOptions.body !== 'string') {\n        copyOptions.body = JSON.stringify(copyOptions.body)\n      }\n\n      const task = wx.request({\n        url,\n        data: copyOptions.body,\n        timeout: reqClass._timeout,\n        method: copyOptions.method || 'GET',\n        header: copyOptions.headers,\n        success(res) {\n          res = dealAdapterRequestData(res, { ...options, url })\n\n          if (res.error) {\n            reject(res)\n          }\n          resolve(res)\n        },\n        fail(err) {\n          reject({\n            error: 'unreachable',\n            error_description: (err as Error).message,\n          })\n        },\n        complete(err) {\n          if (!err || !err.errMsg) {\n            return\n          }\n          if (!reqClass._timeout || reqClass._restrictedMethods.indexOf('request') === -1) {\n            return\n          }\n          const { errMsg } = err\n          if (errMsg === 'request:fail timeout') {\n            console.warn(reqClass._timeoutMsg)\n            try {\n              task.abort()\n            } catch (e) {}\n          }\n        },\n      })\n    })\n  }\n}\n\n/**\n * Get url path.\n * @param {string} url\n * @return {string}\n */\nfunction getUrlPath(url: string) {\n  // return path if matched, or original url\n  return URL_REG.test(url) ? RegExp.$1 : url\n}\n\n/**\n * 用户自定义adapter处理\n * @param config\n * @param adapter\n * @returns\n */\nconst dealUserAdapter = (config: AuthOptions, adapter: SDKAdapterInterface) => {\n  const data = { ...config }\n\n  try {\n    if (!config?.storage && adapter?.localStorage) {\n      data.storage = new OauthClientStorageBase({ localStorage: adapter.localStorage, adapter })\n    }\n\n    if (!config.captchaOptions && adapter?.captchaOptions) {\n      data.captchaOptions = adapter.captchaOptions\n    }\n\n    // 用户未传入baseRequest和request时处理\n    // OAuth2Client优先以 baseRequest 为准\n    // Auth 在没有 request 的时候会初始化 Captcha，从而使用 Captcha 的 request\n    if (!config.baseRequest && !config.request && adapter?.reqClass) {\n      const reqClassParams = {\n        timeout: 10000,\n        restrictedMethods: ['get', 'post', 'upload', 'download', 'request'],\n      }\n      const adapterReq = new adapter.reqClass(reqClassParams)\n      data.baseRequest = async function (url: string, options?: { method?: string; [key: string]: any }) {\n        let res: any = {}\n\n        const requestType = options.method?.toLocaleLowerCase() || 'post'\n\n        const func = adapterReq?.[requestType]?.bind?.(adapterReq)\n\n        if (typeof func !== 'function') {\n          throw new Error(`invalid 【${requestType}】 request method`)\n        }\n\n        try {\n          // 兼容非小程序的adapter\n          if ((!options.headers?.['content-type'] || options.headers?.['content-type'].includes('application/json')) && !['string', 'undefined'].includes(typeof options.body)) {\n            options.data = options.data || options.body\n            options.body = JSON.stringify(options.body)\n          }\n          res = await func({ url, ...options })\n          res = dealAdapterRequestData(res, { ...options, url })\n        } catch (error) {\n          res = { ...error?.data, ...error }\n          throw res\n        }\n\n        if (res?.error) {\n          throw res\n        }\n\n        return res\n      }\n    }\n  } catch (e) {\n    console.error('user adapter generate fail:', e)\n  }\n\n  return data\n}\n\n/**\n * 内置默认adapter处理\n * @param config\n * @returns\n */\nconst dealAuthAdapter = (config: AuthOptions, adapter: SDKAdapterInterface) => {\n  const data = { ...config }\n  const authOptions: any = {}\n\n  if (adapter?.captchaOptions) {\n    data.captchaOptions = adapter.captchaOptions\n  }\n\n  if (!adapterForWxMp.isMatch() || (config.storage && config.baseRequest)) return data\n\n  try {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const { localStorage, reqClass: ReqClass } = adapterForWxMp.genAdapter({})\n    if (localStorage) {\n      authOptions.storage = new OauthClientStorageBase({ localStorage, adapter })\n    }\n    if (ReqClass) {\n      const reqClass = new ReqClass({\n        timeout: 10000,\n        restrictedMethods: ['get', 'post', 'upload', 'download', 'request'],\n      })\n      authOptions.request = generateOauthClientRequest(reqClass)\n    }\n\n    if (data.captchaOptions) {\n      authOptions.baseRequest = authOptions.request\n      authOptions.request = undefined\n    }\n\n    return { ...data, ...authOptions }\n  } catch (e) {\n    console.error('adapter generate fail:', e)\n  }\n\n  return data\n}\n\nexport const useAuthAdapter = (config: AuthOptions) => {\n  // 兼容微搭cloud-sdk，auth中js-sdk默认的adapter不进行配置\n  if (config.adapter && (config.adapter as any).type !== 'default') {\n    return dealUserAdapter(config, config.adapter)\n  }\n\n  return dealAuthAdapter(config, config.adapter)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { SDKAdapterInterface } from '@cloudbase/adapter-interface'\nimport { adapterForWxMp } from './utilities'\nimport type { AuthOptions } from '@cloudbase/oauth'\n\ndeclare const wx: any\n\nclass OauthClientStorageBase {\n  public readonly localStorage\n  constructor(config?: { localStorage: any /* StorageInterface */; adapter: SDKAdapterInterface }) {\n    try {\n      this.localStorage = config?.localStorage || (config?.adapter?.root?.globalThis || globalThis).localStorage\n    } catch (error) {\n      this.localStorage = config?.localStorage || {}\n    }\n  }\n  /**\n   * Get Item\n   * @param {string} key\n   * @return {Promise<string | null>}\n   */\n  async getItem(key: string): Promise<string | null> {\n    return this.localStorage.getItem(key)\n  }\n\n  /**\n   * Remove Item.\n   * @param {string} key\n   * @return {Promise<void>}\n   */\n  async removeItem(key: string) {\n    this.localStorage.removeItem(key)\n  }\n\n  /**\n   * Set Item.\n   * @param {string} key\n   * @param {string} value\n   * @return {Promise<void>}\n   */\n  async setItem(key: string, value: string): Promise<void> {\n    this.localStorage.setItem(key, value)\n  }\n\n  getItemSync(key: string): string | null {\n    return this.localStorage.getItem(key)\n  }\n\n  setItemSync(key: string, value: string) {\n    this.localStorage.setItem(key, value)\n  }\n\n  removeItemSync(key: string) {\n    this.localStorage.removeItem(key)\n  }\n}\n\n/**\n * copy to git@git.woa.com:QBase/lcap/datasource.git/packages/cloud-sdk/common\n * 同步修改\n */\nconst URL_REG = /^[^:]+:\\/\\/[^/]+(\\/[^?#]+)/\n\nconst dealAdapterRequestData = (res, options) => {\n  const requestId = options?.headers?.['x-request-id']\n\n  if (!res) {\n    res = {}\n  }\n\n  if (res?.code || res?.data?.error_code) {\n    res = {\n      error: res.code || res.data.error,\n      error_description: res.data.error_description || res.message || res.code || res.data.error_code,\n      request_id: res.requestId,\n      error_code: res.data?.error_code,\n    }\n  }\n\n  if (!res?.request_id) {\n    res.request_id = res.request_id || requestId\n  }\n\n  if (res?.error) {\n    res.error_uri = getUrlPath(options?.url)\n    return res\n  }\n\n  return res?.data || {}\n}\n\nfunction generateOauthClientRequest(reqClass) {\n  return async function (\n    url: string,\n    options?: {\n      body?: any | null\n      headers?: any | null\n      method?: string\n      [key: string]: any\n    },\n  ) {\n    return new Promise((resolve, reject) => {\n      // Objects must be copied to prevent modification of data such as body.\n      const copyOptions = Object.assign({}, options)\n      if (copyOptions.body && typeof copyOptions.body !== 'string') {\n        copyOptions.body = JSON.stringify(copyOptions.body)\n      }\n\n      const task = wx.request({\n        url,\n        data: copyOptions.body,\n        timeout: reqClass._timeout,\n        method: copyOptions.method || 'GET',\n        header: copyOptions.headers,\n        success(res) {\n          res = dealAdapterRequestData(res, { ...options, url })\n\n          if (res.error) {\n            reject(res)\n          }\n          resolve(res)\n        },\n        fail(err) {\n          reject({\n            error: 'unreachable',\n            error_description: (err as Error).message,\n          })\n        },\n        complete(err) {\n          if (!err || !err.errMsg) {\n            return\n          }\n          if (!reqClass._timeout || reqClass._restrictedMethods.indexOf('request') === -1) {\n            return\n          }\n          const { errMsg } = err\n          if (errMsg === 'request:fail timeout') {\n            console.warn(reqClass._timeoutMsg)\n            try {\n              task.abort()\n            } catch (e) {}\n          }\n        },\n      })\n    })\n  }\n}\n\n/**\n * Get url path.\n * @param {string} url\n * @return {string}\n */\nfunction getUrlPath(url: string) {\n  // return path if matched, or original url\n  return URL_REG.test(url) ? RegExp.$1 : url\n}\n\n/**\n * 用户自定义adapter处理\n * @param config\n * @param adapter\n * @returns\n */\nconst dealUserAdapter = (config: AuthOptions, adapter: SDKAdapterInterface) => {\n  const data = { ...config }\n\n  try {\n    if (!config?.storage && adapter?.localStorage) {\n      data.storage = new OauthClientStorageBase({ localStorage: adapter.localStorage, adapter })\n    }\n\n    if (!config.captchaOptions && adapter?.captchaOptions) {\n      data.captchaOptions = adapter.captchaOptions\n    }\n\n    // 用户未传入baseRequest和request时处理\n    // OAuth2Client优先以 baseRequest 为准\n    // Auth 在没有 request 的时候会初始化 Captcha，从而使用 Captcha 的 request\n    if (!config.baseRequest && !config.request && adapter?.reqClass) {\n      const reqClassParams = {\n        timeout: 10000,\n        restrictedMethods: ['get', 'post', 'upload', 'download', 'request'],\n        auth: config.auth,\n      }\n      const adapterReq = new adapter.reqClass(reqClassParams)\n      data.baseRequest = async function (url: string, options?: { method?: string; [key: string]: any }) {\n        let res: any = {}\n\n        const requestType = options.method?.toLocaleLowerCase() || 'post'\n\n        const func = adapterReq?.[requestType]?.bind?.(adapterReq)\n\n        if (typeof func !== 'function') {\n          throw new Error(`invalid 【${requestType}】 request method`)\n        }\n\n        try {\n          // 兼容非小程序的adapter\n          if ((!options.headers?.['content-type'] || options.headers?.['content-type'].includes('application/json')) && !['string', 'undefined'].includes(typeof options.body)) {\n            options.data = options.data || options.body\n            options.body = JSON.stringify(options.body)\n          }\n          res = await func({ url, ...options })\n          res = dealAdapterRequestData(res, { ...options, url })\n        } catch (error) {\n          res = { ...error?.data, ...error }\n          throw res\n        }\n\n        if (res?.error) {\n          throw res\n        }\n\n        return res\n      }\n    }\n  } catch (e) {\n    console.error('user adapter generate fail:', e)\n  }\n\n  return data\n}\n\n/**\n * 内置默认adapter处理\n * @param config\n * @returns\n */\nconst dealAuthAdapter = (config: AuthOptions, adapter: SDKAdapterInterface) => {\n  const data = { ...config }\n  const authOptions: any = {}\n\n  if (adapter?.captchaOptions) {\n    data.captchaOptions = adapter.captchaOptions\n  }\n\n  if (!adapterForWxMp.isMatch() || (config.storage && config.baseRequest)) return data\n\n  try {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const { localStorage, reqClass: ReqClass } = adapterForWxMp.genAdapter({})\n    if (localStorage) {\n      authOptions.storage = new OauthClientStorageBase({ localStorage, adapter })\n    }\n    if (ReqClass) {\n      const reqClass = new ReqClass({\n        timeout: 10000,\n        restrictedMethods: ['get', 'post', 'upload', 'download', 'request'],\n      })\n      authOptions.request = generateOauthClientRequest(reqClass)\n    }\n\n    if (data.captchaOptions) {\n      authOptions.baseRequest = authOptions.request\n      authOptions.request = undefined\n    }\n\n    return { ...data, ...authOptions }\n  } catch (e) {\n    console.error('adapter generate fail:', e)\n  }\n\n  return data\n}\n\nexport const useAuthAdapter = (config: AuthOptions) => {\n  // 兼容微搭cloud-sdk，auth中js-sdk默认的adapter不进行配置\n  if (config.adapter && (config.adapter as any).type !== 'default') {\n    return dealUserAdapter(config, config.adapter)\n  }\n\n  return dealAuthAdapter(config, config.adapter)\n}\n"]}