@descope/angular-sdk 0.0.0-next-cd745c61-20250421 → 0.0.0-next-20174009-20250429

package/dist/esm2022/lib/services/descope-auth.service.mjs

@@ -0,0 +1,145 @@
+import { Injectable } from '@angular/core';
+import createSdk from '@descope/web-js-sdk';
+import { BehaviorSubject, finalize, tap } from 'rxjs';
+import { observabilify } from '../utils/helpers';
+import { baseHeaders, isBrowser } from '../utils/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "../types/types";
+export class DescopeAuthService {
+    constructor(config) {
+        this.descopeSdk = observabilify(createSdk({
+            persistTokens: isBrowser(),
+            ...config,
+            storeLastAuthenticatedUser: isBrowser(),
+            autoRefresh: isBrowser(),
+            baseHeaders
+        }));
+        this.sessionSubject = new BehaviorSubject({
+            isAuthenticated: false,
+            isSessionLoading: false,
+            sessionToken: ''
+        });
+        this.session$ = this.sessionSubject.asObservable();
+        this.userSubject = new BehaviorSubject({
+            isUserLoading: false
+        });
+        this.user$ = this.userSubject.asObservable();
+        this.descopeSdk.onSessionTokenChange(this.setSession.bind(this));
+        this.descopeSdk.onIsAuthenticatedChange(this.setIsAuthenticated.bind(this));
+        this.descopeSdk.onUserChange(this.setUser.bind(this));
+    }
+    refreshSession() {
+        const beforeRefreshSession = this.sessionSubject.value;
+        this.sessionSubject.next({
+            ...beforeRefreshSession,
+            isSessionLoading: true
+        });
+        return this.descopeSdk.refresh().pipe(finalize(() => {
+            const afterRefreshSession = this.sessionSubject.value;
+            this.sessionSubject.next({
+                ...afterRefreshSession,
+                isSessionLoading: false
+            });
+        }));
+    }
+    refreshUser() {
+        const beforeRefreshUser = this.userSubject.value;
+        this.userSubject.next({
+            ...beforeRefreshUser,
+            isUserLoading: true
+        });
+        return this.descopeSdk.me().pipe(tap((data) => {
+            const afterRequestUser = this.userSubject.value;
+            if (data.data) {
+                this.userSubject.next({
+                    ...afterRequestUser,
+                    user: {
+                        ...data.data
+                    }
+                });
+            }
+        }), finalize(() => {
+            const afterRefreshUser = this.userSubject.value;
+            this.userSubject.next({
+                ...afterRefreshUser,
+                isUserLoading: false
+            });
+        }));
+    }
+    getSessionToken() {
+        if (isBrowser()) {
+            return this.descopeSdk.getSessionToken();
+        }
+        console.warn('Get session token is not supported in SSR');
+        return '';
+    }
+    getRefreshToken() {
+        if (isBrowser()) {
+            return this.descopeSdk.getRefreshToken();
+        }
+        this.descopeSdk.getJwtPermissions;
+        console.warn('Get refresh token is not supported in SSR');
+        return '';
+    }
+    isSessionTokenExpired(token = this.getSessionToken()) {
+        if (isBrowser()) {
+            return this.descopeSdk.isJwtExpired(token ?? '');
+        }
+        console.warn('isSessionTokenExpired is not supported in SSR');
+        return true;
+    }
+    isRefreshTokenExpired(token = this.getRefreshToken()) {
+        if (isBrowser()) {
+            return this.descopeSdk.isJwtExpired(token ?? '');
+        }
+        console.warn('isRefreshTokenExpired is not supported in SSR');
+        return true;
+    }
+    getJwtPermissions(token = this.getSessionToken(), tenant) {
+        if (token === null) {
+            console.error('Could not get JWT Permissions - not authenticated');
+            return [];
+        }
+        return this.descopeSdk.getJwtPermissions(token, tenant);
+    }
+    getJwtRoles(token = this.getSessionToken(), tenant) {
+        if (token === null) {
+            console.error('Could not get JWT Roles - not authenticated');
+            return [];
+        }
+        return this.descopeSdk.getJwtRoles(token, tenant);
+    }
+    isAuthenticated() {
+        return this.sessionSubject.value.isAuthenticated;
+    }
+    setSession(sessionToken) {
+        const currentSession = this.sessionSubject.value;
+        this.sessionSubject.next({
+            ...currentSession,
+            sessionToken
+        });
+    }
+    setIsAuthenticated(isAuthenticated) {
+        const currentSession = this.sessionSubject.value;
+        this.sessionSubject.next({
+            ...currentSession,
+            isAuthenticated
+        });
+    }
+    setUser(user) {
+        const currentUser = this.userSubject.value;
+        this.userSubject.next({
+            isUserLoading: currentUser.isUserLoading,
+            user
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DescopeAuthService, deps: [{ token: i1.DescopeAuthConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DescopeAuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DescopeAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.DescopeAuthConfig }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"descope-auth.service.js","sourceRoot":"","sources":["../../../../projects/angular-sdk/src/lib/services/descope-auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n// workaround for TS issue https://github.com/microsoft/TypeScript/issues/42873\n// eslint-disable-next-line\nimport type * as _1 from '@descope/core-js-sdk';\nimport { Injectable } from '@angular/core';\nimport type { UserResponse } from '@descope/web-js-sdk';\nimport type * as _2 from 'oidc-client-ts'; // eslint-disable-line\nimport createSdk from '@descope/web-js-sdk';\nimport { BehaviorSubject, finalize, Observable, tap } from 'rxjs';\nimport { observabilify, Observablefied } from '../utils/helpers';\nimport { baseHeaders, isBrowser } from '../utils/constants';\nimport { DescopeAuthConfig } from '../types/types';\n\ntype DescopeSDK = ReturnType<typeof createSdk>;\ntype AngularDescopeSDK = Observablefied<DescopeSDK>;\n\nexport interface DescopeSession {\n  isAuthenticated: boolean;\n  isSessionLoading: boolean;\n  sessionToken: string | null;\n}\n\nexport type DescopeUser = {\n  user?: UserResponse | null;\n  isUserLoading: boolean;\n};\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DescopeAuthService {\n  public descopeSdk: AngularDescopeSDK;\n  private readonly sessionSubject: BehaviorSubject<DescopeSession>;\n  private readonly userSubject: BehaviorSubject<DescopeUser>;\n  readonly session$: Observable<DescopeSession>;\n  readonly user$: Observable<DescopeUser>;\n\n  constructor(config: DescopeAuthConfig) {\n    this.descopeSdk = observabilify<DescopeSDK>(\n      createSdk({\n        persistTokens: isBrowser() as true,\n        ...config,\n        storeLastAuthenticatedUser: isBrowser() as true,\n        autoRefresh: isBrowser() as true,\n        baseHeaders\n      })\n    );\n\n    this.sessionSubject = new BehaviorSubject<DescopeSession>({\n      isAuthenticated: false,\n      isSessionLoading: false,\n      sessionToken: ''\n    });\n    this.session$ = this.sessionSubject.asObservable();\n    this.userSubject = new BehaviorSubject<DescopeUser>({\n      isUserLoading: false\n    });\n    this.user$ = this.userSubject.asObservable();\n    this.descopeSdk.onSessionTokenChange(this.setSession.bind(this));\n    this.descopeSdk.onIsAuthenticatedChange(this.setIsAuthenticated.bind(this));\n    this.descopeSdk.onUserChange(this.setUser.bind(this));\n  }\n\n  refreshSession() {\n    const beforeRefreshSession = this.sessionSubject.value;\n    this.sessionSubject.next({\n      ...beforeRefreshSession,\n      isSessionLoading: true\n    });\n    return this.descopeSdk.refresh().pipe(\n      finalize(() => {\n        const afterRefreshSession = this.sessionSubject.value;\n        this.sessionSubject.next({\n          ...afterRefreshSession,\n          isSessionLoading: false\n        });\n      })\n    );\n  }\n\n  refreshUser() {\n    const beforeRefreshUser = this.userSubject.value;\n    this.userSubject.next({\n      ...beforeRefreshUser,\n      isUserLoading: true\n    });\n    return this.descopeSdk.me().pipe(\n      tap((data) => {\n        const afterRequestUser = this.userSubject.value;\n        if (data.data) {\n          this.userSubject.next({\n            ...afterRequestUser,\n            user: {\n              ...data.data\n            }\n          });\n        }\n      }),\n      finalize(() => {\n        const afterRefreshUser = this.userSubject.value;\n        this.userSubject.next({\n          ...afterRefreshUser,\n          isUserLoading: false\n        });\n      })\n    );\n  }\n\n  getSessionToken() {\n    if (isBrowser()) {\n      return (\n        this.descopeSdk as AngularDescopeSDK & {\n          getSessionToken: () => string | null;\n        }\n      ).getSessionToken();\n    }\n    console.warn('Get session token is not supported in SSR');\n    return '';\n  }\n\n  getRefreshToken() {\n    if (isBrowser()) {\n      return (\n        this.descopeSdk as AngularDescopeSDK & {\n          getRefreshToken: () => string | null;\n        }\n      ).getRefreshToken();\n    }\n    this.descopeSdk.getJwtPermissions;\n    console.warn('Get refresh token is not supported in SSR');\n    return '';\n  }\n\n  isSessionTokenExpired(token = this.getSessionToken()) {\n    if (isBrowser()) {\n      return this.descopeSdk.isJwtExpired(token ?? '');\n    }\n    console.warn('isSessionTokenExpired is not supported in SSR');\n    return true;\n  }\n\n  isRefreshTokenExpired(token = this.getRefreshToken()) {\n    if (isBrowser()) {\n      return (\n        this.descopeSdk as AngularDescopeSDK & {\n          isJwtExpired: (token: string) => boolean | null;\n        }\n      ).isJwtExpired(token ?? '');\n    }\n    console.warn('isRefreshTokenExpired is not supported in SSR');\n    return true;\n  }\n\n  getJwtPermissions(token = this.getSessionToken(), tenant?: string) {\n    if (token === null) {\n      console.error('Could not get JWT Permissions - not authenticated');\n      return [];\n    }\n    return this.descopeSdk.getJwtPermissions(token, tenant);\n  }\n\n  getJwtRoles(token = this.getSessionToken(), tenant?: string) {\n    if (token === null) {\n      console.error('Could not get JWT Roles - not authenticated');\n      return [];\n    }\n    return this.descopeSdk.getJwtRoles(token, tenant);\n  }\n\n  isAuthenticated() {\n    return this.sessionSubject.value.isAuthenticated;\n  }\n\n  setSession(sessionToken: string | null) {\n    const currentSession = this.sessionSubject.value;\n    this.sessionSubject.next({\n      ...currentSession,\n      sessionToken\n    });\n  }\n\n  setIsAuthenticated(isAuthenticated: boolean) {\n    const currentSession = this.sessionSubject.value;\n    this.sessionSubject.next({\n      ...currentSession,\n      isAuthenticated\n    });\n  }\n\n  setUser(user: UserResponse | null) {\n    const currentUser = this.userSubject.value;\n    this.userSubject.next({\n      isUserLoading: currentUser.isUserLoading,\n      user\n    });\n  }\n}\n"]}

package/dist/esm2022/lib/services/descope.interceptor.mjs

@@ -0,0 +1,51 @@
+import { inject } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+import { DescopeAuthService } from './descope-auth.service';
+import { DescopeAuthConfig } from '../types/types';
+export const descopeInterceptor = (request, next) => {
+    const config = inject(DescopeAuthConfig);
+    const authService = inject(DescopeAuthService);
+    function refreshAndRetry(request, next, error) {
+        return authService.refreshSession().pipe(switchMap((refreshed) => {
+            if (refreshed.ok && refreshed.data) {
+                const requestWithRefreshedToken = addTokenToRequest(request, refreshed.data?.sessionJwt);
+                return next(requestWithRefreshedToken);
+            }
+            else {
+                return throwError(() => error ?? new Error('Could not refresh session!'));
+            }
+        }));
+    }
+    function shouldIntercept(request) {
+        return ((config.pathsToIntercept?.length === 0 ||
+            config.pathsToIntercept?.some((path) => request.url.includes(path))) ??
+            true);
+    }
+    function addTokenToRequest(request, token) {
+        return request.clone({
+            setHeaders: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+    }
+    if (shouldIntercept(request)) {
+        const token = authService.getSessionToken();
+        if (!token) {
+            return refreshAndRetry(request, next);
+        }
+        const requestWithToken = addTokenToRequest(request, token);
+        return next(requestWithToken).pipe(catchError((error) => {
+            if (error.status === 401 || error.status === 403) {
+                return refreshAndRetry(request, next, error);
+            }
+            else {
+                return throwError(() => error);
+            }
+        }));
+    }
+    else {
+        return next(request);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzY29wZS5pbnRlcmNlcHRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItc2RrL3NyYy9saWIvc2VydmljZXMvZGVzY29wZS5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBT3ZDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDbEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVuRCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBc0IsQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLEVBQUU7SUFDckUsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDekMsTUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFFL0MsU0FBUyxlQUFlLENBQ3RCLE9BQTZCLEVBQzdCLElBQW1CLEVBQ25CLEtBQXlCO1FBRXpCLE9BQU8sV0FBVyxDQUFDLGNBQWMsRUFBRSxDQUFDLElBQUksQ0FDdEMsU0FBUyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUU7WUFDdEIsSUFBSSxTQUFTLENBQUMsRUFBRSxJQUFJLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDbkMsTUFBTSx5QkFBeUIsR0FBRyxpQkFBaUIsQ0FDakQsT0FBTyxFQUNQLFNBQVMsQ0FBQyxJQUFJLEVBQUUsVUFBVSxDQUMzQixDQUFDO2dCQUNGLE9BQU8sSUFBSSxDQUFDLHlCQUF5QixDQUFDLENBQUM7WUFDekMsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE9BQU8sVUFBVSxDQUNmLEdBQUcsRUFBRSxDQUFDLEtBQUssSUFBSSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxDQUN2RCxDQUFDO1lBQ0osQ0FBQztRQUNILENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDO0lBRUQsU0FBUyxlQUFlLENBQUMsT0FBNkI7UUFDcEQsT0FBTyxDQUNMLENBQUMsTUFBTSxDQUFDLGdCQUFnQixFQUFFLE1BQU0sS0FBSyxDQUFDO1lBQ3BDLE1BQU0sQ0FBQyxnQkFBZ0IsRUFBRSxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDdEUsSUFBSSxDQUNMLENBQUM7SUFDSixDQUFDO0lBRUQsU0FBUyxpQkFBaUIsQ0FDeEIsT0FBNkIsRUFDN0IsS0FBYTtRQUViLE9BQU8sT0FBTyxDQUFDLEtBQUssQ0FBQztZQUNuQixVQUFVLEVBQUU7Z0JBQ1YsYUFBYSxFQUFFLFVBQVUsS0FBSyxFQUFFO2FBQ2pDO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELElBQUksZUFBZSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7UUFDN0IsTUFBTSxLQUFLLEdBQUcsV0FBVyxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQzVDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNYLE9BQU8sZUFBZSxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztRQUN4QyxDQUFDO1FBQ0QsTUFBTSxnQkFBZ0IsR0FBRyxpQkFBaUIsQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDM0QsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxJQUFJLENBQ2hDLFVBQVUsQ0FBQyxDQUFDLEtBQXdCLEVBQUUsRUFBRTtZQUN0QyxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssR0FBRyxJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7Z0JBQ2pELE9BQU8sZUFBZSxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7WUFDL0MsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE9BQU8sVUFBVSxDQUFDLEdBQUcsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ2pDLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ0osQ0FBQztTQUFNLENBQUM7UUFDTixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN2QixDQUFDO0FBQ0gsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICBIdHRwRXJyb3JSZXNwb25zZSxcbiAgSHR0cEhhbmRsZXJGbixcbiAgSHR0cEludGVyY2VwdG9yRm4sXG4gIEh0dHBSZXF1ZXN0XG59IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IHRocm93RXJyb3IgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IGNhdGNoRXJyb3IsIHN3aXRjaE1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IERlc2NvcGVBdXRoU2VydmljZSB9IGZyb20gJy4vZGVzY29wZS1hdXRoLnNlcnZpY2UnO1xuaW1wb3J0IHsgRGVzY29wZUF1dGhDb25maWcgfSBmcm9tICcuLi90eXBlcy90eXBlcyc7XG5cbmV4cG9ydCBjb25zdCBkZXNjb3BlSW50ZXJjZXB0b3I6IEh0dHBJbnRlcmNlcHRvckZuID0gKHJlcXVlc3QsIG5leHQpID0+IHtcbiAgY29uc3QgY29uZmlnID0gaW5qZWN0KERlc2NvcGVBdXRoQ29uZmlnKTtcbiAgY29uc3QgYXV0aFNlcnZpY2UgPSBpbmplY3QoRGVzY29wZUF1dGhTZXJ2aWNlKTtcblxuICBmdW5jdGlvbiByZWZyZXNoQW5kUmV0cnkoXG4gICAgcmVxdWVzdDogSHR0cFJlcXVlc3Q8dW5rbm93bj4sXG4gICAgbmV4dDogSHR0cEhhbmRsZXJGbixcbiAgICBlcnJvcj86IEh0dHBFcnJvclJlc3BvbnNlXG4gICkge1xuICAgIHJldHVybiBhdXRoU2VydmljZS5yZWZyZXNoU2Vzc2lvbigpLnBpcGUoXG4gICAgICBzd2l0Y2hNYXAoKHJlZnJlc2hlZCkgPT4ge1xuICAgICAgICBpZiAocmVmcmVzaGVkLm9rICYmIHJlZnJlc2hlZC5kYXRhKSB7XG4gICAgICAgICAgY29uc3QgcmVxdWVzdFdpdGhSZWZyZXNoZWRUb2tlbiA9IGFkZFRva2VuVG9SZXF1ZXN0KFxuICAgICAgICAgICAgcmVxdWVzdCxcbiAgICAgICAgICAgIHJlZnJlc2hlZC5kYXRhPy5zZXNzaW9uSnd0XG4gICAgICAgICAgKTtcbiAgICAgICAgICByZXR1cm4gbmV4dChyZXF1ZXN0V2l0aFJlZnJlc2hlZFRva2VuKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICByZXR1cm4gdGhyb3dFcnJvcihcbiAgICAgICAgICAgICgpID0+IGVycm9yID8/IG5ldyBFcnJvcignQ291bGQgbm90IHJlZnJlc2ggc2Vzc2lvbiEnKVxuICAgICAgICAgICk7XG4gICAgICAgIH1cbiAgICAgIH0pXG4gICAgKTtcbiAgfVxuXG4gIGZ1bmN0aW9uIHNob3VsZEludGVyY2VwdChyZXF1ZXN0OiBIdHRwUmVxdWVzdDx1bmtub3duPik6IGJvb2xlYW4ge1xuICAgIHJldHVybiAoXG4gICAgICAoY29uZmlnLnBhdGhzVG9JbnRlcmNlcHQ/Lmxlbmd0aCA9PT0gMCB8fFxuICAgICAgICBjb25maWcucGF0aHNUb0ludGVyY2VwdD8uc29tZSgocGF0aCkgPT4gcmVxdWVzdC51cmwuaW5jbHVkZXMocGF0aCkpKSA/P1xuICAgICAgdHJ1ZVxuICAgICk7XG4gIH1cblxuICBmdW5jdGlvbiBhZGRUb2tlblRvUmVxdWVzdChcbiAgICByZXF1ZXN0OiBIdHRwUmVxdWVzdDx1bmtub3duPixcbiAgICB0b2tlbjogc3RyaW5nXG4gICk6IEh0dHBSZXF1ZXN0PHVua25vd24+IHtcbiAgICByZXR1cm4gcmVxdWVzdC5jbG9uZSh7XG4gICAgICBzZXRIZWFkZXJzOiB7XG4gICAgICAgIEF1dGhvcml6YXRpb246IGBCZWFyZXIgJHt0b2tlbn1gXG4gICAgICB9XG4gICAgfSk7XG4gIH1cblxuICBpZiAoc2hvdWxkSW50ZXJjZXB0KHJlcXVlc3QpKSB7XG4gICAgY29uc3QgdG9rZW4gPSBhdXRoU2VydmljZS5nZXRTZXNzaW9uVG9rZW4oKTtcbiAgICBpZiAoIXRva2VuKSB7XG4gICAgICByZXR1cm4gcmVmcmVzaEFuZFJldHJ5KHJlcXVlc3QsIG5leHQpO1xuICAgIH1cbiAgICBjb25zdCByZXF1ZXN0V2l0aFRva2VuID0gYWRkVG9rZW5Ub1JlcXVlc3QocmVxdWVzdCwgdG9rZW4pO1xuICAgIHJldHVybiBuZXh0KHJlcXVlc3RXaXRoVG9rZW4pLnBpcGUoXG4gICAgICBjYXRjaEVycm9yKChlcnJvcjogSHR0cEVycm9yUmVzcG9uc2UpID0+IHtcbiAgICAgICAgaWYgKGVycm9yLnN0YXR1cyA9PT0gNDAxIHx8IGVycm9yLnN0YXR1cyA9PT0gNDAzKSB7XG4gICAgICAgICAgcmV0dXJuIHJlZnJlc2hBbmRSZXRyeShyZXF1ZXN0LCBuZXh0LCBlcnJvcik7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoKCkgPT4gZXJyb3IpO1xuICAgICAgICB9XG4gICAgICB9KVxuICAgICk7XG4gIH0gZWxzZSB7XG4gICAgcmV0dXJuIG5leHQocmVxdWVzdCk7XG4gIH1cbn07XG4iXX0=

package/dist/esm2022/lib/types/types.mjs

@@ -0,0 +1,6 @@
+export class DescopeAuthConfig {
+    constructor() {
+        this.projectId = '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXNkay9zcmMvbGliL3R5cGVzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxpQkFBaUI7SUFBOUI7UUFDRSxjQUFTLEdBQUcsRUFBRSxDQUFDO0lBVWpCLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElMb2dnZXIgfSBmcm9tICdAZGVzY29wZS93ZWItY29tcG9uZW50JztcbmltcG9ydCB7IENvb2tpZUNvbmZpZyB9IGZyb20gJ0BkZXNjb3BlL3dlYi1qcy1zZGsnO1xuZXhwb3J0IGNsYXNzIERlc2NvcGVBdXRoQ29uZmlnIHtcbiAgcHJvamVjdElkID0gJyc7XG4gIGJhc2VVcmw/OiBzdHJpbmc7XG4gIGJhc2VTdGF0aWNVcmw/OiBzdHJpbmc7XG4gIGJhc2VDZG5Vcmw/OiBzdHJpbmc7XG4gIC8vIElmIHRydWUsIHRva2VucyB3aWxsIGJlIHN0b3JlZCBvbiBsb2NhbCBzdG9yYWdlXG4gIHBlcnNpc3RUb2tlbnM/OiBib29sZWFuO1xuICBzZXNzaW9uVG9rZW5WaWFDb29raWU/OiBDb29raWVDb25maWc7XG4gIC8vIElmIHRydWUsIGxhc3QgYXV0aGVudGljYXRlZCB1c2VyIHdpbGwgYmUgc3RvcmVkIG9uIGxvY2FsIHN0b3JhZ2UgYW5kIGNhbiBhY2Nlc3NlZCB3aXRoIGdldFVzZXIgZnVuY3Rpb25cbiAgc3RvcmVMYXN0QXV0aGVudGljYXRlZFVzZXI/OiBib29sZWFuO1xuICBwYXRoc1RvSW50ZXJjZXB0Pzogc3RyaW5nW107XG59XG5cbmV4cG9ydCB0eXBlIHsgSUxvZ2dlciB9O1xuIl19

package/dist/esm2022/lib/utils/constants.mjs

@@ -0,0 +1,7 @@
+import { environment } from '../../environment';
+export const baseHeaders = {
+    'x-descope-sdk-name': 'angular',
+    'x-descope-sdk-version': environment.buildVersion
+};
+export const isBrowser = () => typeof window !== 'undefined';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1zZGsvc3JjL2xpYi91dGlscy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWhELE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRztJQUN6QixvQkFBb0IsRUFBRSxTQUFTO0lBQy9CLHVCQUF1QixFQUFFLFdBQVcsQ0FBQyxZQUFZO0NBQ2xELENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsR0FBRyxFQUFFLENBQUMsT0FBTyxNQUFNLEtBQUssV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZW52aXJvbm1lbnQgfSBmcm9tICcuLi8uLi9lbnZpcm9ubWVudCc7XG5cbmV4cG9ydCBjb25zdCBiYXNlSGVhZGVycyA9IHtcbiAgJ3gtZGVzY29wZS1zZGstbmFtZSc6ICdhbmd1bGFyJyxcbiAgJ3gtZGVzY29wZS1zZGstdmVyc2lvbic6IGVudmlyb25tZW50LmJ1aWxkVmVyc2lvblxufTtcblxuZXhwb3J0IGNvbnN0IGlzQnJvd3NlciA9ICgpID0+IHR5cGVvZiB3aW5kb3cgIT09ICd1bmRlZmluZWQnO1xuIl19

package/dist/esm2022/lib/utils/helpers.mjs

@@ -0,0 +1,27 @@
+import { from } from 'rxjs';
+export function observabilify(value) {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    const observableValue = {};
+    for (const key in value) {
+        if (typeof value[key] === 'function') {
+            const fn = value[key];
+            observableValue[key] = (...args) => {
+                const fnResult = fn(...args);
+                if (fnResult instanceof Promise) {
+                    return from(fnResult);
+                }
+                else {
+                    return fnResult;
+                }
+            };
+        }
+        else if (typeof value[key] === 'object' && value[key] !== null) {
+            observableValue[key] = observabilify(value[key]);
+        }
+        else {
+            observableValue[key] = value[key];
+        }
+    }
+    return observableValue;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/public-api.mjs

@@ -0,0 +1,19 @@
+/*
+ * Public API Surface of angular-sdk
+ */
+export * from './lib/services/descope-auth.service';
+export * from './lib/services/descope-auth.guard';
+export * from './lib/services/descope.interceptor';
+export * from './lib/descope-auth.module';
+export * from './lib/components/descope/descope.component';
+export * from './lib/components/sign-in-flow/sign-in-flow.component';
+export * from './lib/components/sign-up-flow/sign-up-flow.component';
+export * from './lib/components/sign-up-or-in-flow/sign-up-or-in-flow.component';
+export * from './lib/components/user-management/user-management.component';
+export * from './lib/components/role-management/role-management.component';
+export * from './lib/components/access-key-management/access-key-management.component';
+export * from './lib/components/audit-management/audit-management.component';
+export * from './lib/components/user-profile/user-profile.component';
+export * from './lib/components/applications-portal/applications-portal.component';
+export * from './lib/types/types';
+//# sourceMappingURL=data:application/json;base64,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