angular-auth-oidc-client/esm2022/lib/provide-auth.mjs

Angular Lib for OpenID Connect & OAuth2

import { APP_INITIALIZER, makeEnvironmentProviders, } from '@angular/core';
import { createStaticLoader, PASSED_CONFIG, } from './auth-config';
import { StsConfigLoader } from './config/loader/config-loader';
import { AbstractLoggerService } from './logging/abstract-logger.service';
import { ConsoleLoggerService } from './logging/console-logger.service';
import { OidcSecurityService } from './oidc.security.service';
import { AbstractSecurityStorage } from './storage/abstract-security-storage';
import { DefaultSessionStorageService } from './storage/default-sessionstorage.service';
export function provideAuth(passedConfig, ...features) {
    const providers = _provideAuth(passedConfig);
    for (const feature of features) {
        providers.push(...feature.ɵproviders);
    }
    return makeEnvironmentProviders(providers);
}
export function _provideAuth(passedConfig) {
    return [
        // Make the PASSED_CONFIG available through injection
        { provide: PASSED_CONFIG, useValue: passedConfig },
        // Create the loader: Either the one getting passed or a static one
        passedConfig?.loader || {
            provide: StsConfigLoader,
            useFactory: createStaticLoader,
            deps: [PASSED_CONFIG],
        },
        {
            provide: AbstractSecurityStorage,
            useClass: DefaultSessionStorageService,
        },
        { provide: AbstractLoggerService, useClass: ConsoleLoggerService },
    ];
}
/**
 * Configures an app initializer, which is called before the app starts, and
 * resolves any OAuth callback variables.
 * When used, it replaces the need to manually call
 * `OidcSecurityService.checkAuth(...)` or
 * `OidcSecurityService.checkAuthMultiple(...)`.
 *
 * @see https://angular.dev/api/core/APP_INITIALIZER
 */
export function withAppInitializerAuthCheck() {
    return {
        ɵproviders: [
            {
                provide: APP_INITIALIZER,
                useFactory: (oidcSecurityService) => () => oidcSecurityService.checkAuthMultiple(),
                multi: true,
                deps: [OidcSecurityService],
            },
        ],
    };
}
//# sourceMappingURL=data:application/json;base64,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