@cloudbase/auth 2.26.0 → 2.26.2

package/dist/esm/v1-compat.js

@@ -0,0 +1,419 @@
+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 };
+    }
+};
+import { LOGIN_STATE_CHANGED_TYPE, AUTH_STATE_CHANGED_TYPE, } from '@cloudbase/oauth';
+import { throwError, ERRORS, } from './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;
+}());
+export { 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;
+}());
+export { 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;
+}());
+export { 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') {
+                            throwError(ERRORS.INVALID_PARAMS, 'email must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            throwError(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') {
+                            throwError(ERRORS.INVALID_PARAMS, 'email must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            throwError(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') {
+                            throwError(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') {
+                            throwError(ERRORS.INVALID_PARAMS, 'username must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            throwError(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') {
+                            throwError(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') {
+                            throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
+                        }
+                        if (typeof phoneCode !== 'string') {
+                            throwError(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') {
+                            throwError(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:
+                        throwError(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') {
+                            throwError(ERRORS.INVALID_PARAMS, 'phoneNumber must be a string');
+                        }
+                        if (typeof phoneCode !== 'string') {
+                            throwError(ERRORS.INVALID_PARAMS, 'phoneCode must be a string');
+                        }
+                        if (typeof password !== 'string') {
+                            throwError(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) === LOGIN_STATE_CHANGED_TYPE.CREDENTIALS_ERROR) {
+                callback.call(_this);
+            }
+        });
+    };
+    AuthV1Compat.prototype.onAccessTokenRefreshed = function (callback) {
+        var _this = this;
+        this.onAuthStateChange(function (event) {
+            if (event === AUTH_STATE_CHANGED_TYPE.TOKEN_REFRESHED) {
+                callback.call(_this);
+            }
+        });
+    };
+    AuthV1Compat.prototype.onAnonymousConverted = function (callback) {
+        var _this = this;
+        this.onAuthStateChange(function (event) {
+            if (event === AUTH_STATE_CHANGED_TYPE.SIGNED_IN) {
+                callback.call(_this);
+            }
+        });
+    };
+    AuthV1Compat.prototype.onLoginTypeChanged = function (callback) {
+        var _this = this;
+        this.onAuthStateChange(function (event) {
+            if (event === AUTH_STATE_CHANGED_TYPE.SIGNED_IN || event === AUTH_STATE_CHANGED_TYPE.SIGNED_OUT) {
+                callback.call(_this);
+            }
+        });
+    };
+    return AuthV1Compat;
+}());
+export { AuthV1Compat };
+export 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') {
+                            throwError(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 }) 替代。');
+            });
+        });
+    };
+}
+//# 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"]}