Class SessionMonitor

src/SessionMonitor.ts:12–179

 * @public
 */
export class SessionMonitor {
    private readonly _logger = new Logger("SessionMonitor");

    private _sub: string | undefined;
    private _checkSessionIFrame?: CheckSessionIFrame;

    public constructor(private readonly _userManager: UserManager) {
        if (!_userManager) {
            this._logger.throw(new Error("No user manager passed"));
        }

        this._userManager.events.addUserLoaded(this._start);
        this._userManager.events.addUserUnloaded(this._stop);

        this._init().catch((err: unknown) => {
            // catch to suppress errors since we're in a ctor
            this._logger.error(err);
        });
    }

    protected async _init(): Promise<void> {
        this._logger.create("_init");
        const user = await this._userManager.getUser();
        // doing this manually here since calling getUser
        // doesn't trigger load event.
        if (user) {
            void this._start(user);
        }
        else if (this._userManager.settings.monitorAnonymousSession) {
            const session = await this._userManager.querySessionStatus();
            if (session) {
                const tmpUser = {
                    session_state: session.session_state,
                    profile: session.sub ? {
                        sub: session.sub,
                    } : null,
                };
                void this._start(tmpUser);
            }
        }
    }

    protected _start = async (
        user: User | {
            session_state: string;
            profile: { sub: string } | null;
        },
    ): Promise<void> => {
        const session_state = user.session_state;
        if (!session_state) {
            return;
        }
        const logger = this._logger.create("_start");

        if (user.profile) {
            this._sub = user.profile.sub;
            logger.debug("session_state", session_state, ", sub", this._sub);
        }