ngx-oauth 3.0.1 → 4.1.0

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

@@ -0,0 +1,80 @@
+var _TokenService_token$;
+import { __classPrivateFieldGet } from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, distinctUntilChanged, of, switchMap } from 'rxjs';
+import { HEADER_APPLICATION } 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: i2.HttpClient }, { 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 }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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