@cloudbase/auth 3.1.8 → 3.1.9

package/dist/cjs/v1-compat.d.ts

@@ -0,0 +1,77 @@
+import type { authModels } from '@cloudbase/oauth';
+import type { SignUpRes } from './type';
+export declare class WeixinAuthProvider {
+    constructor(_options: {
+        authInstance: any;
+        appid: string;
+        scope: string;
+    });
+    signInWithRedirect(): void;
+    getRedirectResult(_options?: {
+        createUser?: boolean;
+        syncUserInfo?: boolean;
+    }): Promise<any>;
+    getLinkRedirectResult(_options?: {
+        withUnionId?: boolean;
+    }): Promise<void>;
+}
+export declare class CustomAuthProvider {
+    private authInstance;
+    constructor(options: {
+        authInstance: any;
+    });
+    signIn(ticket: string): Promise<void>;
+}
+export declare class AnonymousAuthProvider {
+    private authInstance;
+    constructor(options: {
+        authInstance: any;
+    });
+    signIn(): Promise<void>;
+}
+export declare abstract class AuthV1Compat {
+    abstract readonly config: any;
+    weixinAuthProvider(options: {
+        appid: string;
+        scope: string;
+    }): WeixinAuthProvider;
+    customAuthProvider(): CustomAuthProvider;
+    anonymousAuthProvider(): AnonymousAuthProvider;
+    signUpWithEmailAndPassword(email: string, password: string): Promise<SignUpRes>;
+    signInWithEmailAndPassword(email: string, password: string): Promise<any>;
+    sendPasswordResetEmail(email: string): Promise<void>;
+    signInWithUsernameAndPassword(username: string, password: string): Promise<any>;
+    sendPhoneCode(phoneNumber: string): Promise<boolean>;
+    signUpWithPhoneCode(phoneNumber: string, phoneCode: string, password?: string): Promise<any>;
+    signInWithPhoneCodeOrPassword(params: {
+        phoneNumber: string;
+        phoneCode?: string;
+        password?: string;
+    }): Promise<any>;
+    forceResetPwdByPhoneCode(params: {
+        phoneNumber: string;
+        phoneCode: string;
+        password: string;
+    }): Promise<any>;
+    shouldRefreshAccessToken(_callback: () => boolean): void;
+    onLoginStateExpired(callback: Function): void;
+    onAccessTokenRefreshed(callback: Function): void;
+    onAnonymousConverted(callback: Function): void;
+    onLoginTypeChanged(callback: Function): void;
+    abstract signIn(params: authModels.SignInRequest): Promise<any>;
+    abstract signUp(params: authModels.SignUpRequest & {
+        phone?: string;
+    }): Promise<SignUpRes>;
+    abstract signInWithCustomTicket(getTickFn?: authModels.GetCustomSignTicketFn): Promise<any>;
+    abstract signInAnonymously(params: any): Promise<any>;
+    abstract getVerification(params: any, options?: any): Promise<authModels.GetVerificationResponse>;
+    abstract resetPassword(params: authModels.ResetPasswordRequest): Promise<void>;
+    abstract onLoginStateChanged(callback: Function): Promise<void>;
+    abstract onAuthStateChange(callback: any): any;
+    abstract createLoginState(params?: any, options?: any): Promise<any>;
+    abstract signInWithOAuth(params: any): Promise<any>;
+    abstract grantProviderToken(params: authModels.GrantProviderTokenRequest): Promise<authModels.GrantProviderTokenResponse>;
+    abstract bindWithProvider(params: authModels.BindWithProviderRequest): Promise<void>;
+    protected abstract formatPhone(phone: string): string;
+}
+export declare function applyUserV1Compat(UserClass: any): void;

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/index.d.ts

@@ -4,6 +4,7 @@ import type { ICloudbaseRequest } from '@cloudbase/types/request';
 import type { ICloudbaseAuthConfig, IUser, ILoginState } from '@cloudbase/types/auth';
 import type { AuthOptions, Credentials } from '@cloudbase/oauth';
 import { CloudbaseOAuth, AuthError, authModels } from '@cloudbase/oauth';
+import { AuthV1Compat, WeixinAuthProvider, CustomAuthProvider, AnonymousAuthProvider } from './v1-compat';
 import { CommonRes, DeleteMeReq, GetClaimsRes, GetUserIdentitiesRes, GetUserRes, LinkIdentityReq, LinkIdentityRes, OnAuthStateChangeCallback, ReauthenticateRes, ResendReq, ResendRes, ResetPasswordForEmailRes, ResetPasswordForOldReq, SetSessionReq, SignInAnonymouslyReq, SignInOAuthRes, SignInRes, SignInWithIdTokenReq, SignInWithOAuthReq, SignInWithOtpReq, SignInWithOtpRes, SignInWithPasswordReq, SignUpRes, UnlinkIdentityReq, UpdateUserReq, UpdateUserWithVerificationRes, VerifyOAuthReq, VerifyOAuthRes, VerifyOtpReq } from './type';
 export type { SignInRes, GetUserRes, CommonRes, SignInWithOtpRes, SignInOAuthRes, GetClaimsRes, ResetPasswordForEmailRes, GetUserIdentitiesRes, LinkIdentityRes, ReauthenticateRes, ResendRes, UpdateUserWithVerificationRes, OnAuthStateChangeCallback, SignInWithPasswordReq, SignInWithIdTokenReq, SignInWithOAuthReq, VerifyOAuthReq, VerifyOtpReq, LinkIdentityReq, UnlinkIdentityReq, UpdateUserReq, SignInWithOtpReq, ResetPasswordForOldReq, ResendReq, SetSessionReq, DeleteMeReq, SignUpRes, } from './type';
 interface UserInfo {
@@ -79,7 +80,7 @@ interface IAuthConfig extends ICloudbaseAuthConfig {
     request?: ICloudbaseRequest;
     runtime?: string;
 }
-declare class Auth {
+declare class Auth extends AuthV1Compat {
     readonly config: IAuthConfig;
     oauthInstance: CloudbaseOAuth;
     readonly cache: ICloudbaseCache;
@@ -249,7 +250,7 @@ declare class Auth {
     signInWithPhoneAuth({ phoneCode }: {
         phoneCode?: string;
     }): Promise<SignInRes>;
-    private formatPhone;
+    protected formatPhone(phone: string): string;
     private notifyListeners;
     private setupListeners;
     private convertToUser;
@@ -275,5 +276,5 @@ export declare function generateAuthInstance(config: TInitAuthOptions & {
     authInstance: Auth;
     oauthInstance: CloudbaseOAuth;
 };
-export { UserInfo, Auth };
+export { UserInfo, Auth, WeixinAuthProvider, CustomAuthProvider, AnonymousAuthProvider };
 export declare function registerAuth(app: Pick<ICloudbase, 'registerComponent'>): void;