ngx-oauth 3.0.2 → 4.2.0

package/esm2020/lib/services/token.service.mjs

@@ -0,0 +1,83 @@
+var _TokenService_token$;
+import { __classPrivateFieldGet } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, distinctUntilChanged, of, switchMap } from 'rxjs';
+import { HEADER_APPLICATION, OAUTH_HTTP_CLIENT } from '../models';
+import { catchError, map, shareReplay } from 'rxjs/operators';
+import { HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../models";
+import * as i2 from "@angular/common/http";
+const isExpiredToken = (token) => token && token.expires && Date.now() > token.expires || false;
+export class TokenService {
+    constructor(authConfig, http, zone) {
+        this.authConfig = authConfig;
+        this.http = http;
+        this.zone = zone;
+        _TokenService_token$.set(this, new BehaviorSubject(this.saved));
+        this.token$ = __classPrivateFieldGet(this, _TokenService_token$, "f").pipe(distinctUntilChanged((p, c) => JSON.stringify(p || null) === JSON.stringify(c || null)), switchMap(token => !isExpiredToken(token) && of(token) || this.refreshToken(token)), shareReplay(1));
+        this.type$ = this.token$.pipe(map(token => token?.type), shareReplay(1));
+        this.accessToken$ = this.token$.pipe(map(token => token?.access_token), shareReplay(1));
+    }
+    get token() {
+        return __classPrivateFieldGet(this, _TokenService_token$, "f").value;
+    }
+    set token(token) {
+        const expiresIn = Number(token.expires_in) || 0;
+        const result = {
+            ...token,
+            ...expiresIn && { expires: Date.now() + expiresIn * 1000 } || {}
+        };
+        this.saved = result;
+        __classPrivateFieldGet(this, _TokenService_token$, "f").next(result);
+    }
+    get saved() {
+        const { storageKey, storage } = this.authConfig;
+        return storageKey && storage && storage[storageKey] && JSON.parse(storage[storageKey]) || {};
+    }
+    set saved(token) {
+        const { storageKey, storage } = this.authConfig;
+        if (storage && storageKey) {
+            if (token) {
+                storage[storageKey] = JSON.stringify(token);
+            }
+            else {
+                delete storage[storageKey];
+            }
+        }
+    }
+    refreshToken(token) {
+        const { tokenPath, clientId, clientSecret, scope } = this.authConfig.config;
+        const { refresh_token } = token || {};
+        return tokenPath && refresh_token && this.http.post(tokenPath, new HttpParams({
+            fromObject: {
+                client_id: clientId,
+                ...clientSecret && { client_secret: clientSecret } || {},
+                grant_type: 'refresh_token',
+                refresh_token,
+                ...scope && { scope } || {},
+            }
+        }), {
+            headers: HEADER_APPLICATION
+        }).pipe(catchError(() => {
+            this.token = {};
+            return of(this.token);
+        }), map(token => {
+            this.token = {
+                ...this.token,
+                ...token
+            };
+            return this.token;
+        })) || of(token);
+    }
+}
+_TokenService_token$ = new WeakMap();
+TokenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: TokenService, deps: [{ token: i1.OAuthConfig }, { token: OAUTH_HTTP_CLIENT }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+TokenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: TokenService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.OAuthConfig }, { type: i2.HttpClient, decorators: [{
+                    type: Inject,
+                    args: [OAUTH_HTTP_CLIENT]
+                }] }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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