{
  "version": 3,
  "sources": ["libs/rx-utils/src/lib/subscription-list.ts", "libs/rx-utils/src/lib/scrollable.ts", "libs/rx-utils/src/lib/filter-null-and-undefined.ts", "libs/rx-utils/src/lib/vax/index.ts", "libs/rx-utils/src/lib/one-result.ts", "libs/rx-utils/src/lib/array-distinct.ts", "libs/rx-utils/src/lib/switch-when.ts", "libs/rx-utils/src/lib/index.ts", "libs/rx-utils/src/index.ts"],
  "sourcesContent": ["import { Observable, Subscription } from 'rxjs';\n\nexport class SubscriptionList {\n  static new(): SubscriptionList {\n    return new SubscriptionList();\n  }\n\n  static fromList(list: Subscription[]): SubscriptionList {\n    return new SubscriptionList(Array.from(list));\n  }\n\n  private constructor(private readonly subscriptions: Subscription[] = []) {}\n\n  destroy(): void {\n    this.subscriptions.forEach((s) => s.unsubscribe());\n  }\n\n  add<T>(inputs: Observable<T>, subscriptionFunction?: (T: any) => void): void {\n    this.subscriptions.push(inputs.subscribe(subscriptionFunction));\n  }\n\n  addSub(subscription: Subscription): void {\n    this.subscriptions.push(subscription);\n  }\n\n  asList(): Subscription[] {\n    return Array.from(this.subscriptions);\n  }\n\n  addAll(...subs: Subscription[]): void {\n    this.subscriptions.push(...subs);\n  }\n}\n", "import { asapScheduler, Observable, Subject } from 'rxjs';\nimport {\n  distinctUntilChanged,\n  map,\n  observeOn,\n  shareReplay,\n  startWith,\n  switchMap,\n  take,\n  takeWhile,\n} from 'rxjs/operators';\n\n/**\n * @param criteria$ An observable of metadata that \"resets\" the scroll operation back to the start. This could include search terms, filters, sort order, etc.\n * @param callback A function that takes in the paging metadata, fetches the next page, and returns the new items and metadata.\n * @param trigger$ An observable used to trigger the next page of items to be fetched.\n * @returns An observable state containing the paged items and the paging metadata.\n *\n * @example\n *\n * // Examples of criteria\n * const searchText$ = new BehaviorSubject<string>('');\n * const critera$ = searchText$.pipe(distinctUntilChanged(), debounceTime(500));\n *\n * const filters$ = ...\n * const sortOrder$ = ...\n * const criteria$ = combineLatest([searchText$, filters$, sortOrder$]).pipe(debounceTime(500));\n *\n * // Example of callback\n * (criteria, cursor) => {\n *   const { searchText, filters, sortOrder } = criteria;\n *   return someApiCall(searchText, filters, sortOrder, cursor).pipe(\n *    map(response => ({\n *      // You must normalize your response fields to \"items\", \"cursor\", and \"hasMore\"\n *      items: response.someItems,\n *      cursor: response.cursor,\n *      hasMore: response.hasMore,\n *    })\n *  );\n * }\n *\n * // Example of trigger\n * const trigger$ = new Subject();\n */\nexport const scrollable = <ItemType, Criteria>(\n  criteria$: Observable<Criteria>,\n  callback: (\n    criteria: Criteria,\n    cursor: string,\n  ) => Observable<{ items: ItemType[]; cursor: string; hasMore: boolean; totalResults?: number }>,\n  trigger$: Observable<unknown>,\n) => {\n  return criteria$.pipe(\n    observeOn(asapScheduler),\n    switchMap((criteria: Criteria) => {\n      let cursor: string = null;\n      let hasMore = true;\n      let items: ItemType[] = [];\n      return trigger$.pipe(\n        startWith(true),\n        takeWhile(() => hasMore),\n        switchMap(() => {\n          return callback(criteria, cursor).pipe(\n            take(1),\n            map((result) => {\n              cursor = result.cursor;\n              hasMore = result.hasMore;\n              if (result.items) {\n                items = [...items, ...result.items];\n              }\n              return {\n                items,\n                loading: false,\n                hasMore,\n                empty: items.length === 0 && !hasMore,\n                totalResults: result.totalResults || null,\n                criteria,\n              };\n            }),\n            startWith({ items, loading: true, hasMore: true, empty: false, totalResults: null, criteria }),\n          );\n        }),\n      );\n    }),\n    shareReplay({ refCount: true, bufferSize: 1 }),\n  );\n};\n\nexport class Scrollable<ItemType, Criteria> {\n  readonly state$ = scrollable(this.criteria$, this.callback, this.trigger$);\n  readonly items$ = this.state$.pipe(\n    map((value) => value.items),\n    distinctUntilChanged(),\n  );\n  readonly loading$ = this.state$.pipe(\n    map((value) => value.loading),\n    distinctUntilChanged(),\n  );\n  readonly hasMore$ = this.state$.pipe(\n    map((value) => value.hasMore),\n    distinctUntilChanged(),\n  );\n  readonly empty$ = this.state$.pipe(\n    map((value) => value.empty),\n    distinctUntilChanged(),\n  );\n  readonly totalResults$ = this.state$.pipe(map((value) => value.totalResults));\n\n  /**\n   * @param criteria$ An observable of metadata that \"resets\" the scroll operation back to the start. This could include search terms, filters, sort order, etc.\n   * @param callback A function that takes in the paging metadata, fetches the next page, and returns the new items and metadata.\n   * @param trigger$ A subject used to trigger the next page of items to be fetched.\n   *\n   * @see scrollable for more information on these parameters and examples of their use.\n   */\n  constructor(\n    private readonly criteria$: Observable<Criteria>,\n    private readonly callback: (\n      criteria: Criteria,\n      cursor: string,\n    ) => Observable<{ items: ItemType[]; cursor: string; hasMore: boolean; totalResults?: number }>,\n    private readonly trigger$ = new Subject<void>(),\n  ) {}\n\n  loadMore(): void {\n    this.trigger$.next();\n  }\n}\n", "import { filter } from 'rxjs/operators';\n\n/**\n * Provide to an observable pipe to filter out emitted values that are undefined or null.\n *\n * The filter function is a type guard so the type of the returned observable will be refined to not include undefined or null.\n *\n * ```\n * o$: Observable<Foo | undefined | null> = ...\n * // The explicit type below for o2$ isn't required (it can be inferred)\n * // but it is used here to demonstrate the type refinement\n * o2$: Observable<Foo> = o$.pipe(\n *  tap((v) => {\n *    // v might be undefined or null here\n *  })\n *  filterNullAndUndefined(),\n *  map((v) => {\n *   // v will not be undefined or null here\n *  }),\n * )\n * ```\n */\nexport function filterNullAndUndefined<T>() {\n  return filter(isNotNullOrUndefined<T>);\n}\n\nexport function isNotNullOrUndefined<T>(x: T | undefined | null): x is T {\n  return x !== undefined && x !== null;\n}\n", "import { HttpErrorResponse } from '@angular/common/http';\nimport {\n  Observable,\n  of as observableOf,\n  race,\n  range,\n  ReplaySubject,\n  throwError as observableThrowError,\n  timer,\n} from 'rxjs';\nimport { delayWhen, first, merge, retryWhen, skip, switchMap, tap, zip } from 'rxjs/operators';\n\nexport interface RetryConfig {\n  // Maximimum amount of time to retry before giving up.\n  timeoutMilliseconds?: number;\n  // Maximimum number of times to retry before giving up.\n  maxAttempts?: number;\n  // Initial delay between retries. The delay doubles on each subsequent retry.\n  retryDelay?: number;\n  // A custom predicate to determine whether to retry on an http error.\n  customRetryChecker?: (errResp: HttpErrorResponse) => boolean;\n}\n\nconst DEFAULT_TIMEOUT_MILLIS = 5000;\nconst DEFAULT_MAX_ATTEMPTS = 10;\nconst DEFAULT_RETRY_DELAY_MILLIS = 200;\nconst DEFAULT_RETRY_CHECKER: ((errResp: HttpErrorResponse) => boolean | null) | null = null;\n\n/**\n * This class wraps an http call in retry logic according to a configuration.\n *\n * Only to be used for idempotent calls.\n */\nexport class Retryer<T> {\n  public result$: Observable<T>;\n  private retriedErrors$$ = new ReplaySubject<HttpErrorResponse>(1);\n\n  private timeoutMilliseconds: number;\n  private maxAttempts: number | null;\n  private retryDelay: number;\n  private customRetryChecker: ((errResp: HttpErrorResponse) => boolean | null) | null;\n\n  /**\n   *\n   * @param call The http call or observable to be retried through subscribing\n   * @param config Configure the retry logic\n   */\n  constructor(call: Observable<T>, config?: RetryConfig) {\n    const {\n      timeoutMilliseconds = DEFAULT_TIMEOUT_MILLIS,\n      maxAttempts = DEFAULT_MAX_ATTEMPTS,\n      retryDelay = DEFAULT_RETRY_DELAY_MILLIS,\n      customRetryChecker = DEFAULT_RETRY_CHECKER,\n    } = config || {};\n    this.timeoutMilliseconds = timeoutMilliseconds;\n    this.maxAttempts = maxAttempts;\n    this.retryDelay = retryDelay;\n    this.customRetryChecker = customRetryChecker;\n\n    this.result$ = call.pipe(\n      retryWhen((errors$: Observable<HttpErrorResponse>) => this.getRetries(errors$)),\n      first(),\n    );\n  }\n\n  private getRetries(errors$: Observable<HttpErrorResponse>): Observable<any> {\n    return errors$.pipe(\n      tap((err) => this.retriedErrors$$.next(err)),\n      switchMap((errResp) => (this.shouldRetry(errResp) ? observableOf(errResp) : observableThrowError(errResp))),\n      zip(range(0, this.maxAttempts - 1), (err, tryNumber) => tryNumber),\n      delayWhen((tryNumber) => this.getDelayTimer(tryNumber)),\n      merge(this.getCutoffNotifier(errors$)),\n    );\n  }\n\n  private getCutoffNotifier(errors$: Observable<HttpErrorResponse>): Observable<HttpErrorResponse> {\n    const maxTimeout$ = timer(this.timeoutMilliseconds);\n    const throwLastError$ = this.retriedErrors$$.pipe(switchMap((err) => observableThrowError(err)));\n    const maxAttempts$ = errors$.pipe(skip(this.maxAttempts - 1), first());\n\n    return race<any>(maxTimeout$, maxAttempts$).pipe(switchMap(() => throwLastError$));\n  }\n\n  private shouldRetry(err: HttpErrorResponse): boolean {\n    if (this.customRetryChecker !== null && this.customRetryChecker !== undefined) {\n      return this.customRetryChecker(err);\n    }\n    if (err.error instanceof Error) {\n      // non HTTP Error means a client error or network error occurred, we should retry\n      return true;\n    }\n    return err.status >= 500;\n  }\n\n  private getDelayTimer(tryNumber: number): Observable<any> {\n    const exponentialBackoffDelay = Math.pow(2, tryNumber) * this.retryDelay;\n    return timer(exponentialBackoffDelay).pipe(first());\n  }\n}\n\n/**\n * Usage: httpClient.get('example.com').let(retryWith(retryConfig))\n * OR:    httpClient.get('example.com').pipe( retryWith(retryConfig) );\n * @param config Retry configuration\n */\nexport const retryer =\n  <T>(config?: RetryConfig) =>\n  (call: Observable<T>): Observable<T> => {\n    return new Retryer(call, config).result$;\n  };\n", "import { Observable } from 'rxjs';\nimport { take } from 'rxjs/operators';\n\n/**\n * @deprecated Use firstValueFrom or lastValueFrom from RXJS\n */\nexport function oneResultFrom<T>(ob: Observable<T>): Promise<T> {\n  return ob.pipe(take(1)).toPromise();\n}\n\nexport function oneResultFromEach<V1>(ob: [Observable<V1>]): Promise<V1>[];\nexport function oneResultFromEach<V1, V2>(ob: [Observable<V1>, Observable<V2>]): [Promise<V1>, Promise<V2>];\nexport function oneResultFromEach<V1, V2, V3>(\n  ob: [Observable<V1>, Observable<V2>, Observable<V3>],\n): [Promise<V1>, Promise<V2>, Promise<V3>];\nexport function oneResultFromEach<V1, V2, V3, V4>(\n  ob: [Observable<V1>, Observable<V2>, Observable<V3>, Observable<V4>],\n): [Promise<V1>, Promise<V2>, Promise<V3>, Promise<V4>];\n\nexport function oneResultFromEach(ob: Observable<any>[]): Promise<any>[] {\n  return ob.map((o) => oneResultFrom(o));\n}\n", "import { MonoTypeOperatorFunction } from 'rxjs';\nimport { distinctUntilChanged } from 'rxjs/operators';\n\n/**\n * Same behavior as distinctUntilChanged but specifically for arrays where the comparator is used to compare elements of\n * the arrays.\n *\n * Returns a result Observable that emits all arrays pushed by the source observable if their elements are distinct in\n * comparison to the elements the result observable emitted previously.\n *\n * @param comparator Optional comparison function that is used to compare elements of the arrays. Default is ===.\n */\nexport function arrayDistinctUntilChanged<T>(comparator?: (a: T, b: T) => boolean): MonoTypeOperatorFunction<T[]> {\n  return distinctUntilChanged<T[]>((as, bs) => arrayContentEqual(as, bs, comparator));\n}\n\nexport function arrayContentEqual<T>(as: T[], bs: T[], comparator?: (a: T, b: T) => boolean) {\n  return as.length === bs.length && as.every((a) => bs.some((b) => (comparator ? comparator(a, b) : a === b)));\n}\n", "import { MonoTypeOperatorFunction, ObservableInput, of, switchMap } from 'rxjs';\n\ntype validatorFn<T> = (value: T) => boolean;\n\n/**\n * RxJs operator to switch to a new Observable when a condition is met.\n * @param next new Observable to switch to.\n * @param when validator function to determine when to switch. The source Observable value is passed to this function.\n * @returns the resulting Observable.\n * @example\n * ```ts\n * const source = of('first value');\n * const next = of('alternate value');\n * const result = source.pipe(switchWhen(next, (value) => value === 'first value'));\n * result.subscribe((value) => console.log(value)); // logs 'alternate value'\n * ```\n */\nexport function switchWhen<T>(next: ObservableInput<T>, when: validatorFn<T>): MonoTypeOperatorFunction<T> {\n  return switchMap((value) => {\n    if (when?.(value)) {\n      return next;\n    }\n    return of(value);\n  });\n}\n\n/**\n * RxJs operator to switch to a new Observable when the value of the source Observable is falsy.\n * @param next new Observable to switch to.\n * @returns the resulting Observable.\n * @example\n * ```ts\n * const source = of('');\n * const next = of('alternate value');\n * const result = source.pipe(switchWhenFalsy(next));\n * result.subscribe((value) => console.log(value)); // logs 'alternate value'\n * ```\n */\nexport function switchWhenFalsy<T>(next: ObservableInput<T>): MonoTypeOperatorFunction<T> {\n  return switchWhen(next, (value) => !value);\n}\n", "export { schedule } from './test-scheduler';\nexport { SubscriptionList } from './subscription-list';\nexport { JestScheduler } from './jest-scheduler';\nexport { KeyedCacheOptions, KeyedCache } from './keyed-cache/keyed.cache';\nexport { KeyedItem } from './keyed-cache/abstract-keyed-cache';\nexport { Storage } from './storage';\nexport { expectBool } from './expect-bool';\nexport { oneResultFrom, oneResultFromEach } from './one-result';\nexport { scrollable, Scrollable } from './scrollable';\nexport { filterNullAndUndefined } from './filter-null-and-undefined';\nexport * from './array-distinct';\nexport * from './vax';\nexport * from './switch-when';\n", "export * from './lib/index';\n"],
  "mappings": "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",
  "names": ["SubscriptionList", "init_subscription_list", "__esmMin", "new", "fromList", "list", "Array", "from", "constructor", "subscriptions", "destroy", "forEach", "s", "unsubscribe", "add", "inputs", "subscriptionFunction", "push", "subscribe", "addSub", "subscription", "asList", "addAll", "subs", "scrollable", "Scrollable", "init_scrollable", "__esmMin", "init_esm", "init_operators", "criteria$", "callback", "trigger$", "pipe", "observeOn", "asapScheduler", "switchMap", "criteria", "cursor", "hasMore", "items", "startWith", "takeWhile", "take", "map", "result", "loading", "empty", "length", "totalResults", "shareReplay", "refCount", "bufferSize", "constructor", "Subject", "state$", "items$", "value", "distinctUntilChanged", "loading$", "hasMore$", "empty$", "totalResults$", "loadMore", "next", "filterNullAndUndefined", "filter", "isNotNullOrUndefined", "x", "init_filter_null_and_undefined", "__esmMin", "init_operators", "DEFAULT_TIMEOUT_MILLIS", "DEFAULT_MAX_ATTEMPTS", "DEFAULT_RETRY_DELAY_MILLIS", "DEFAULT_RETRY_CHECKER", "Retryer", "retryer", "init_vax", "__esmMin", "init_esm", "init_operators", "constructor", "call", "config", "retriedErrors$$", "ReplaySubject", "timeoutMilliseconds", "maxAttempts", "retryDelay", "customRetryChecker", "result$", "pipe", "retryWhen", "errors$", "getRetries", "first", "tap", "err", "next", "switchMap", "errResp", "shouldRetry", "observableOf", "observableThrowError", "zip", "range", "tryNumber", "delayWhen", "getDelayTimer", "merge", "getCutoffNotifier", "maxTimeout$", "timer", "throwLastError$", "maxAttempts$", "skip", "race", "undefined", "error", "Error", "status", "exponentialBackoffDelay", "Math", "pow", "oneResultFrom", "ob", "pipe", "take", "toPromise", "init_one_result", "__esmMin", "init_operators", "init_array_distinct", "__esmMin", "switchWhen", "next", "when", "switchMap", "value", "of", "switchWhenFalsy", "init_switch_when", "__esmMin", "init_esm", "init_lib", "__esmMin", "init_subscription_list", "init_one_result", "init_scrollable", "init_filter_null_and_undefined", "init_array_distinct", "init_vax", "init_switch_when", "init_src", "__esmMin", "init_lib"]
}