{"version":3,"sources":["libs/core/src/lib/environment.service.ts","node_modules/@angular/core/fesm2022/rxjs-interop.mjs","libs/core/src/lib/util.ts","libs/core/src/lib/session.service.ts","libs/core/src/lib/auth.interceptor.ts","libs/core/src/lib/core.module.ts","libs/core/src/lib/index.ts","libs/core/src/index.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\n\nexport enum Environment {\n  LOCAL = 0,\n  TEST = 1,\n  DEMO = 2,\n  PROD = 3,\n}\n\nconst environment: string = (globalThis as { environment?: string }).environment || 'prod';\n\n@Injectable({ providedIn: 'root' })\nexport class EnvironmentService {\n  private environment!: Environment;\n\n  constructor() {\n    this.setEnvironment(environment);\n  }\n\n  private setEnvironment(env: string): void {\n    switch (env) {\n      case 'local':\n        this.environment = Environment.LOCAL;\n        break;\n      case 'test':\n        this.environment = Environment.TEST;\n        break;\n      case 'demo':\n        this.environment = Environment.DEMO;\n        break;\n      case 'prod':\n        this.environment = Environment.PROD;\n        break;\n    }\n  }\n\n  getEnvironment(): Environment {\n    return this.environment;\n  }\n\n  getEnvironmentString(): string {\n    switch (this.environment) {\n      case Environment.LOCAL:\n        return 'local';\n      case Environment.TEST:\n        return 'test';\n      case Environment.DEMO:\n        return 'demo';\n      case Environment.PROD:\n      default:\n        return 'prod';\n    }\n  }\n}\n","/**\n * @license Angular v19.1.3\n * (c) 2010-2024 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { assertInInjectionContext, inject, DestroyRef, ɵRuntimeError, ɵgetOutputDestroyRef, Injector, effect, untracked, ɵmicrotaskEffect, assertNotInReactiveContext, signal, computed, PendingTasks, resource } from '@angular/core';\nimport { Observable, ReplaySubject, Subject } from 'rxjs';\nimport { takeUntil, take } from 'rxjs/operators';\n\n/**\n * Operator which completes the Observable when the calling context (component, directive, service,\n * etc) is destroyed.\n *\n * @param destroyRef optionally, the `DestroyRef` representing the current context. This can be\n *     passed explicitly to use `takeUntilDestroyed` outside of an [injection\n * context](guide/di/dependency-injection-context). Otherwise, the current `DestroyRef` is injected.\n *\n * @publicApi\n */\nfunction takeUntilDestroyed(destroyRef) {\n  if (!destroyRef) {\n    assertInInjectionContext(takeUntilDestroyed);\n    destroyRef = inject(DestroyRef);\n  }\n  const destroyed$ = new Observable(observer => {\n    const unregisterFn = destroyRef.onDestroy(observer.next.bind(observer));\n    return unregisterFn;\n  });\n  return source => {\n    return source.pipe(takeUntil(destroyed$));\n  };\n}\n\n/**\n * Implementation of `OutputRef` that emits values from\n * an RxJS observable source.\n *\n * @internal\n */\nclass OutputFromObservableRef {\n  source;\n  destroyed = false;\n  destroyRef = /*#__PURE__*/inject(DestroyRef);\n  constructor(source) {\n    this.source = source;\n    this.destroyRef.onDestroy(() => {\n      this.destroyed = true;\n    });\n  }\n  subscribe(callbackFn) {\n    if (this.destroyed) {\n      throw new ɵRuntimeError(953 /* ɵRuntimeErrorCode.OUTPUT_REF_DESTROYED */, ngDevMode && 'Unexpected subscription to destroyed `OutputRef`. ' + 'The owning directive/component is destroyed.');\n    }\n    // Stop yielding more values when the directive/component is already destroyed.\n    const subscription = this.source.pipe(takeUntilDestroyed(this.destroyRef)).subscribe({\n      next: value => callbackFn(value)\n    });\n    return {\n      unsubscribe: () => subscription.unsubscribe()\n    };\n  }\n}\n/**\n * Declares an Angular output that is using an RxJS observable as a source\n * for events dispatched to parent subscribers.\n *\n * The behavior for an observable as source is defined as followed:\n *    1. New values are forwarded to the Angular output (next notifications).\n *    2. Errors notifications are not handled by Angular. You need to handle these manually.\n *       For example by using `catchError`.\n *    3. Completion notifications stop the output from emitting new values.\n *\n * @usageNotes\n * Initialize an output in your directive by declaring a\n * class field and initializing it with the `outputFromObservable()` function.\n *\n * ```ts\n * @Directive({..})\n * export class MyDir {\n *   nameChange$ = <some-observable>;\n *   nameChange = outputFromObservable(this.nameChange$);\n * }\n * ```\n *\n * @publicApi\n */\nfunction outputFromObservable(observable, opts) {\n  ngDevMode && assertInInjectionContext(outputFromObservable);\n  return new OutputFromObservableRef(observable);\n}\n\n/**\n * Converts an Angular output declared via `output()` or `outputFromObservable()`\n * to an observable.\n *\n * You can subscribe to the output via `Observable.subscribe` then.\n *\n * @publicApi\n */\nfunction outputToObservable(ref) {\n  const destroyRef = ɵgetOutputDestroyRef(ref);\n  return new Observable(observer => {\n    // Complete the observable upon directive/component destroy.\n    // Note: May be `undefined` if an `EventEmitter` is declared outside\n    // of an injection context.\n    destroyRef?.onDestroy(() => observer.complete());\n    const subscription = ref.subscribe(v => observer.next(v));\n    return () => subscription.unsubscribe();\n  });\n}\n\n/**\n * Exposes the value of an Angular `Signal` as an RxJS `Observable`.\n *\n * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.\n *\n * `toObservable` must be called in an injection context unless an injector is provided via options.\n *\n * @developerPreview\n */\nfunction toObservable(source, options) {\n  !options?.injector && assertInInjectionContext(toObservable);\n  const injector = options?.injector ?? inject(Injector);\n  const subject = new ReplaySubject(1);\n  const watcher = effect(() => {\n    let value;\n    try {\n      value = source();\n    } catch (err) {\n      untracked(() => subject.error(err));\n      return;\n    }\n    untracked(() => subject.next(value));\n  }, {\n    injector,\n    manualCleanup: true\n  });\n  injector.get(DestroyRef).onDestroy(() => {\n    watcher.destroy();\n    subject.complete();\n  });\n  return subject.asObservable();\n}\nfunction toObservableMicrotask(source, options) {\n  !options?.injector && assertInInjectionContext(toObservable);\n  const injector = options?.injector ?? inject(Injector);\n  const subject = new ReplaySubject(1);\n  const watcher = ɵmicrotaskEffect(() => {\n    let value;\n    try {\n      value = source();\n    } catch (err) {\n      untracked(() => subject.error(err));\n      return;\n    }\n    untracked(() => subject.next(value));\n  }, {\n    injector,\n    manualCleanup: true\n  });\n  injector.get(DestroyRef).onDestroy(() => {\n    watcher.destroy();\n    subject.complete();\n  });\n  return subject.asObservable();\n}\n\n/**\n * Get the current value of an `Observable` as a reactive `Signal`.\n *\n * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced\n * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always\n * have the most recent value emitted by the subscription, and will throw an error if the\n * `Observable` errors.\n *\n * With `requireSync` set to `true`, `toSignal` will assert that the `Observable` produces a value\n * immediately upon subscription. No `initialValue` is needed in this case, and the returned signal\n * does not include an `undefined` type.\n *\n * By default, the subscription will be automatically cleaned up when the current [injection\n * context](guide/di/dependency-injection-context) is destroyed. For example, when `toSignal` is\n * called during the construction of a component, the subscription will be cleaned up when the\n * component is destroyed. If an injection context is not available, an explicit `Injector` can be\n * passed instead.\n *\n * If the subscription should persist until the `Observable` itself completes, the `manualCleanup`\n * option can be specified instead, which disables the automatic subscription teardown. No injection\n * context is needed in this configuration as well.\n *\n * @developerPreview\n */\nfunction toSignal(source, options) {\n  ngDevMode && assertNotInReactiveContext(toSignal, 'Invoking `toSignal` causes new subscriptions every time. ' + 'Consider moving `toSignal` outside of the reactive context and read the signal value where needed.');\n  const requiresCleanup = !options?.manualCleanup;\n  requiresCleanup && !options?.injector && assertInInjectionContext(toSignal);\n  const cleanupRef = requiresCleanup ? options?.injector?.get(DestroyRef) ?? inject(DestroyRef) : null;\n  const equal = makeToSignalEqual(options?.equal);\n  // Note: T is the Observable value type, and U is the initial value type. They don't have to be\n  // the same - the returned signal gives values of type `T`.\n  let state;\n  if (options?.requireSync) {\n    // Initially the signal is in a `NoValue` state.\n    state = signal({\n      kind: 0 /* StateKind.NoValue */\n    }, {\n      equal\n    });\n  } else {\n    // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.\n    state = signal({\n      kind: 1 /* StateKind.Value */,\n      value: options?.initialValue\n    }, {\n      equal\n    });\n  }\n  // Note: This code cannot run inside a reactive context (see assertion above). If we'd support\n  // this, we would subscribe to the observable outside of the current reactive context, avoiding\n  // that side-effect signal reads/writes are attribute to the current consumer. The current\n  // consumer only needs to be notified when the `state` signal changes through the observable\n  // subscription. Additional context (related to async pipe):\n  // https://github.com/angular/angular/pull/50522.\n  const sub = source.subscribe({\n    next: value => state.set({\n      kind: 1 /* StateKind.Value */,\n      value\n    }),\n    error: error => {\n      if (options?.rejectErrors) {\n        // Kick the error back to RxJS. It will be caught and rethrown in a macrotask, which causes\n        // the error to end up as an uncaught exception.\n        throw error;\n      }\n      state.set({\n        kind: 2 /* StateKind.Error */,\n        error\n      });\n    }\n    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of\n    // \"complete\".\n  });\n  if (options?.requireSync && state().kind === 0 /* StateKind.NoValue */) {\n    throw new ɵRuntimeError(601 /* ɵRuntimeErrorCode.REQUIRE_SYNC_WITHOUT_SYNC_EMIT */, (typeof ngDevMode === 'undefined' || ngDevMode) && '`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');\n  }\n  // Unsubscribe when the current context is destroyed, if requested.\n  cleanupRef?.onDestroy(sub.unsubscribe.bind(sub));\n  // The actual returned signal is a `computed` of the `State` signal, which maps the various states\n  // to either values or errors.\n  return computed(() => {\n    const current = state();\n    switch (current.kind) {\n      case 1 /* StateKind.Value */:\n        return current.value;\n      case 2 /* StateKind.Error */:\n        throw current.error;\n      case 0 /* StateKind.NoValue */:\n        // This shouldn't really happen because the error is thrown on creation.\n        throw new ɵRuntimeError(601 /* ɵRuntimeErrorCode.REQUIRE_SYNC_WITHOUT_SYNC_EMIT */, (typeof ngDevMode === 'undefined' || ngDevMode) && '`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');\n    }\n  }, {\n    equal: options?.equal\n  });\n}\nfunction makeToSignalEqual(userEquality = Object.is) {\n  return (a, b) => a.kind === 1 /* StateKind.Value */ && b.kind === 1 /* StateKind.Value */ && userEquality(a.value, b.value);\n}\n\n/**\n * Operator which makes the application unstable until the observable emits, complets, errors, or is unsubscribed.\n *\n * Use this operator in observables whose subscriptions are important for rendering and should be included in SSR serialization.\n *\n * @param injector The `Injector` to use during creation. If this is not provided, the current injection context will be used instead (via `inject`).\n *\n * @experimental\n */\nfunction pendingUntilEvent(injector) {\n  if (injector === undefined) {\n    assertInInjectionContext(pendingUntilEvent);\n    injector = inject(Injector);\n  }\n  const taskService = injector.get(PendingTasks);\n  return sourceObservable => {\n    return new Observable(originalSubscriber => {\n      // create a new task on subscription\n      const removeTask = taskService.add();\n      let cleanedUp = false;\n      function cleanupTask() {\n        if (cleanedUp) {\n          return;\n        }\n        removeTask();\n        cleanedUp = true;\n      }\n      const innerSubscription = sourceObservable.subscribe({\n        next: v => {\n          originalSubscriber.next(v);\n          cleanupTask();\n        },\n        complete: () => {\n          originalSubscriber.complete();\n          cleanupTask();\n        },\n        error: e => {\n          originalSubscriber.error(e);\n          cleanupTask();\n        }\n      });\n      innerSubscription.add(() => {\n        originalSubscriber.unsubscribe();\n        cleanupTask();\n      });\n      return innerSubscription;\n    });\n  };\n}\n\n/**\n * Like `resource` but uses an RxJS based `loader` which maps the request to an `Observable` of the\n * resource's value. Like `firstValueFrom`, only the first emission of the Observable is considered.\n *\n * @experimental\n */\nfunction rxResource(opts) {\n  opts?.injector || assertInInjectionContext(rxResource);\n  return resource({\n    ...opts,\n    loader: params => {\n      const cancelled = new Subject();\n      params.abortSignal.addEventListener('abort', () => cancelled.next());\n      // Note: this is identical to `firstValueFrom` which we can't use,\n      // because at the time of writing, `core` still supports rxjs 6.x.\n      return new Promise((resolve, reject) => {\n        opts.loader(params).pipe(take(1), takeUntil(cancelled)).subscribe({\n          next: resolve,\n          error: reject,\n          complete: () => reject(new Error('Resource completed before producing a value'))\n        });\n      });\n    }\n  });\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { outputFromObservable, outputToObservable, pendingUntilEvent, rxResource, takeUntilDestroyed, toObservable, toSignal, toObservableMicrotask as ɵtoObservableMicrotask };\n","/**\n * If a component is being used in an iframe with a different domain\n * localstorage access will fail on Chrome\n * https://www.chromium.org/for-testers/bug-reporting-guidelines/uncaught-securityer\\\n * ror-failed-to-read-the-localstorage-property-from-window-access-is-denied-for-thi\\\n * s-document\n *\n * this solution is cited here:\n * https://michalzalecki.com/why-using-localStorage-directly-is-a-bad-idea/\n */\nexport function isLocalStorageAvailable(): boolean {\n  try {\n    const key = '__some_random_key_just_to_test_localstorage__';\n    window.localStorage.setItem(key, key);\n    window.localStorage.removeItem(key);\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n","import { Injectable, WritableSignal, effect, signal, Signal } from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { Observable } from 'rxjs';\nimport { isLocalStorageAvailable } from './util';\n\ndeclare const iamSession: string;\nconst LOCAL_SESSION_KEY = 'local_session';\nconst USE_LOCAL_STORAGE = isLocalStorageAvailable();\n\ninterface SessionServiceInterface {\n  getSessionId(): Observable<string | null>;\n  getSessionIdSignal(): Signal<string | null>;\n  setSessionId(sessionId: string): void;\n  clearSessionId(): void;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class SessionService implements SessionServiceInterface {\n  private readonly sessionIdSubject: WritableSignal<string | null>;\n  private readonly sessionId$: Observable<string | null>;\n\n  constructor() {\n    if (typeof iamSession !== 'undefined' && !!iamSession) {\n      this.sessionIdSubject = signal(iamSession);\n    } else if (USE_LOCAL_STORAGE) {\n      const localSession = this.getLocalStoredSession();\n      this.sessionIdSubject = signal(localSession);\n    } else {\n      this.sessionIdSubject = signal(null);\n    }\n\n    effect(() => {\n      const sessionId = this.sessionIdSubject();\n      if (USE_LOCAL_STORAGE) {\n        this.setLocalStoredSession(sessionId);\n      }\n    });\n\n    this.sessionId$ = toObservable(this.sessionIdSubject);\n  }\n\n  getSessionIdSignal(): Signal<string | null> {\n    return this.sessionIdSubject;\n  }\n\n  getSessionId(): Observable<string | null> {\n    return this.sessionId$;\n  }\n\n  setSessionId(sessionId: string): void {\n    this.sessionIdSubject.set(sessionId);\n  }\n\n  clearSessionId(): void {\n    this.sessionIdSubject.set('');\n  }\n\n  private getLocalStoredSession(): string | null {\n    return localStorage.getItem(LOCAL_SESSION_KEY);\n  }\n\n  private setLocalStoredSession(session: string | null): void {\n    localStorage.setItem(LOCAL_SESSION_KEY, session ?? '');\n  }\n}\n","import { Injectable, Injector } from '@angular/core';\nimport { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { switchMap, first } from 'rxjs/operators';\nimport { SessionService } from './session.service';\n\n@Injectable()\nexport class AuthInterceptor implements HttpInterceptor {\n  constructor(private inj: Injector) {}\n\n  intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {\n    if (!req.withCredentials) {\n      return next.handle(req);\n    }\n    const auth = this.inj.get(SessionService); // Work around for cyclic dependency with app config service\n    return auth.getSessionId().pipe(\n      first(),\n      switchMap((sessionId) => {\n        if (sessionId) {\n          return next.handle(req.clone({ headers: req.headers.set('Authorization', `Bearer ${sessionId}`) }));\n        }\n        return next.handle(req);\n      }),\n    );\n  }\n}\n","import { HTTP_INTERCEPTORS } from '@angular/common/http';\nimport { NgModule } from '@angular/core';\nimport { AuthInterceptor } from './auth.interceptor';\n\n@NgModule({\n  imports: [],\n  providers: [\n    {\n      provide: HTTP_INTERCEPTORS,\n      useClass: AuthInterceptor,\n      multi: true,\n    },\n  ],\n})\nexport class CoreModule {}\n","export * from './environment.service';\nexport * from './session.service';\nexport * from './core.module';\nexport * from './auth.interceptor';\nexport * from './util';\n","export * from './lib';\n"],"mappings":"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","names":["Environment","environment","EnvironmentService","init_environment_service","__esmMin","globalThis","constructor","setEnvironment","env","LOCAL","TEST","DEMO","PROD","getEnvironment","getEnvironmentString","factory","ɵfac","providedIn","takeUntilDestroyed","destroyRef","assertInInjectionContext","inject","DestroyRef","destroyed$","Observable","observer","source","takeUntil","toObservable","options","injector","Injector","subject","ReplaySubject","watcher","effect","value","err","untracked","toSignal","requiresCleanup","cleanupRef","equal","makeToSignalEqual","state","signal","sub","error","RuntimeError","computed","current","userEquality","a","b","rxResource","opts","resource","__spreadProps","__spreadValues","params","cancelled","Subject","resolve","reject","take","init_rxjs_interop","__esmMin","init_core","init_esm","init_operators","isLocalStorageAvailable","key","window","localStorage","setItem","removeItem","init_util","__esmMin","LOCAL_SESSION_KEY","USE_LOCAL_STORAGE","SessionService","init_session_service","__esmMin","init_core","init_rxjs_interop","init_util","isLocalStorageAvailable","constructor","iamSession","sessionIdSubject","signal","localSession","getLocalStoredSession","effect","sessionId","setLocalStoredSession","sessionId$","toObservable","getSessionIdSignal","getSessionId","setSessionId","set","clearSessionId","localStorage","getItem","session","setItem","factory","ɵfac","providedIn","AuthInterceptor","init_auth_interceptor","__esmMin","init_operators","init_session_service","constructor","inj","intercept","req","next","withCredentials","get","SessionService","getSessionId","pipe","first","switchMap","sessionId","handle","clone","headers","set","ɵɵinject","Injector","factory","ɵfac","CoreModule","init_core_module","__esmMin","init_http","init_auth_interceptor","provide","HTTP_INTERCEPTORS","useClass","AuthInterceptor","multi","init_lib","__esmMin","init_environment_service","init_session_service","init_core_module","init_auth_interceptor","init_util","init_src","__esmMin","init_lib"],"x_google_ignoreList":[1]}