@angular/fire
Version:
The official library for Firebase and Angular
480 lines • 42.5 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';
import { concat, EMPTY, Observable, of, pipe } from 'rxjs';
import { debounceTime, distinctUntilChanged, filter, groupBy, map, mergeMap, observeOn, scan, shareReplay, startWith, switchMap, tap, withLatestFrom } from 'rxjs/operators';
import { FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵAngularFireSchedulers, ɵfirebaseAppFactory, ɵkeepUnstableUntilFirstFactory, ɵlazySDKProxy } from '@angular/fire';
import { remoteConfig } from 'firebase/app';
import { isPlatformBrowser } from '@angular/common';
import * as i0 from "@angular/core";
import * as i1 from "@angular/fire";
/**
* @record
*/
export function ConfigTemplate() { }
/** @type {?} */
export const SETTINGS = new InjectionToken('angularfire2.remoteConfig.settings');
/** @type {?} */
export const DEFAULTS = new InjectionToken('angularfire2.remoteConfig.defaultConfig');
// WARNING: interface has both a type and a value, skipping emit
/** @type {?} */
const AS_TO_FN = { strings: 'asString', numbers: 'asNumber', booleans: 'asBoolean' };
/** @type {?} */
const STATIC_VALUES = { numbers: 0, booleans: false, strings: undefined };
// TODO look into the types here, I don't like the anys
/** @type {?} */
const proxyAll = (/**
* @param {?} observable
* @param {?} as
* @return {?}
*/
(observable, as) => (/** @type {?} */ (new Proxy(observable.pipe(mapToObject((/** @type {?} */ (as)))), {
get: (/**
* @param {?} self
* @param {?} name
* @return {?}
*/
(self, name) => self[name] || observable.pipe(map((/**
* @param {?} all
* @return {?}
*/
all => all.find((/**
* @param {?} p
* @return {?}
*/
p => p.key === name)))), map((/**
* @param {?} param
* @return {?}
*/
param => param ? param[AS_TO_FN[as]]() : STATIC_VALUES[as])), distinctUntilChanged()))
}))));
const ɵ0 = proxyAll;
// TODO export as implements Partial<...> so minor doesn't break us
export class Value {
// tslint:disable-next-line:variable-name
/**
* @param {?} _source
* @param {?} _value
*/
constructor(_source, _value) {
this._source = _source;
this._value = _value;
}
/**
* @return {?}
*/
asBoolean() {
return ['1', 'true', 't', 'y', 'yes', 'on'].indexOf(this._value.toLowerCase()) > -1;
}
/**
* @return {?}
*/
asString() {
return this._value;
}
/**
* @return {?}
*/
asNumber() {
return Number(this._value) || 0;
}
/**
* @return {?}
*/
getSource() {
return this._source;
}
}
if (false) {
/** @type {?} */
Value.prototype._source;
/** @type {?} */
Value.prototype._value;
}
// SEMVER use ConstructorParameters when we can support Typescript 3.6
export class Parameter extends Value {
/**
* @param {?} key
* @param {?} fetchTimeMillis
* @param {?} source
* @param {?} value
*/
constructor(key, fetchTimeMillis, source, value) {
super(source, value);
this.key = key;
this.fetchTimeMillis = fetchTimeMillis;
}
}
if (false) {
/** @type {?} */
Parameter.prototype.key;
/** @type {?} */
Parameter.prototype.fetchTimeMillis;
}
// If it's a Parameter array, test any, else test the individual Parameter
/** @type {?} */
const filterTest = (/**
* @param {?} fn
* @return {?}
*/
(fn) => filter((/**
* @param {?} it
* @return {?}
*/
it => Array.isArray(it) ? it.some(fn) : fn(it))));
const ɵ1 = filterTest;
// Allow the user to bypass the default values and wait till they get something from the server, even if it's a cached copy;
// if used in conjuntion with first() it will only fetch RC values from the server if they aren't cached locally
/** @type {?} */
export const filterRemote = (/**
* @return {?}
*/
() => filterTest((/**
* @param {?} p
* @return {?}
*/
p => p.getSource() === 'remote')));
// filterFresh allows the developer to effectively set up a maximum cache time
/** @type {?} */
export const filterFresh = (/**
* @param {?} howRecentInMillis
* @return {?}
*/
(howRecentInMillis) => filterTest((/**
* @param {?} p
* @return {?}
*/
p => p.fetchTimeMillis + howRecentInMillis >= new Date().getTime())));
// I ditched loading the defaults into RC and a simple map for scan since we already have our own defaults implementation.
// The idea here being that if they have a default that never loads from the server, they will be able to tell via fetchTimeMillis
// on the Parameter. Also if it doesn't come from the server it won't emit again in .changes, due to the distinctUntilChanged,
// which we can simplify to === rather than deep comparison
/** @type {?} */
const scanToParametersArray = (/**
* @param {?} remoteConfig
* @return {?}
*/
(remoteConfig) => pipe(withLatestFrom(remoteConfig), scan((/**
* @param {?} existing
* @param {?} __1
* @return {?}
*/
(existing, [all, rc]) => {
// SEMVER use "new Set" to unique once we're only targeting es6
// at the scale we expect remote config to be at, we probably won't see a performance hit from this unoptimized uniqueness
// implementation.
// const allKeys = [...new Set([...existing.map(p => p.key), ...Object.keys(all)])];
/** @type {?} */
const allKeys = [...existing.map((/**
* @param {?} p
* @return {?}
*/
p => p.key)), ...Object.keys(all)].filter((/**
* @param {?} v
* @param {?} i
* @param {?} a
* @return {?}
*/
(v, i, a) => a.indexOf(v) === i));
return allKeys.map((/**
* @param {?} key
* @return {?}
*/
key => {
/** @type {?} */
const updatedValue = all[key];
return updatedValue ? new Parameter(key, rc ? rc.fetchTimeMillis : -1, updatedValue.getSource(), updatedValue.asString())
: existing.find((/**
* @param {?} p
* @return {?}
*/
p => p.key === key));
}));
}), (/** @type {?} */ ([])))));
const ɵ2 = scanToParametersArray;
export class AngularFireRemoteConfig {
/**
* @param {?} options
* @param {?} nameOrConfig
* @param {?} settings
* @param {?} defaultConfig
* @param {?} zone
* @param {?} platformId
*/
constructor(options, nameOrConfig, settings, defaultConfig, zone,
// tslint:disable-next-line:ban-types
platformId) {
this.zone = zone;
/** @type {?} */
const schedulers = new ɵAngularFireSchedulers(zone);
/** @type {?} */
const remoteConfig$ = of(undefined).pipe(observeOn(schedulers.outsideAngular), switchMap((/**
* @return {?}
*/
() => isPlatformBrowser(platformId) ? import('firebase/remote-config') : EMPTY)), map((/**
* @return {?}
*/
() => ɵfirebaseAppFactory(options, zone, nameOrConfig))), map((/**
* @param {?} app
* @return {?}
*/
app => app.remoteConfig())), tap((/**
* @param {?} rc
* @return {?}
*/
rc => {
if (settings) {
rc.settings = settings;
}
if (defaultConfig) {
rc.defaultConfig = defaultConfig;
}
})),
// tslint:disable-next-line
startWith(undefined), shareReplay({ bufferSize: 1, refCount: false }));
/** @type {?} */
const loadedRemoteConfig$ = remoteConfig$.pipe(filter((/**
* @param {?} rc
* @return {?}
*/
rc => !!rc)));
/** @type {?} */
const default$ = of(Object.keys(defaultConfig || {}).reduce((/**
* @param {?} c
* @param {?} k
* @return {?}
*/
(c, k) => (Object.assign(Object.assign({}, c), { [k]: new Value('default', defaultConfig[k].toString()) }))), {}));
// we should filter out the defaults we provided to RC, since we have our own implementation
// that gives us a -1 for fetchTimeMillis (so filterFresh can filter them out)
/** @type {?} */
const filterOutDefaults = map((/**
* @param {?} all
* @return {?}
*/
all => Object.keys(all)
.filter((/**
* @param {?} key
* @return {?}
*/
key => all[key].getSource() !== 'default'))
.reduce((/**
* @param {?} acc
* @param {?} key
* @return {?}
*/
(acc, key) => (Object.assign(Object.assign({}, acc), { [key]: all[key] }))), {})));
/** @type {?} */
const existing$ = loadedRemoteConfig$.pipe(switchMap((/**
* @param {?} rc
* @return {?}
*/
rc => rc.activate()
.then((/**
* @return {?}
*/
() => rc.ensureInitialized()))
.then((/**
* @return {?}
*/
() => rc.getAll())))), filterOutDefaults);
/** @type {?} */
const fresh$ = loadedRemoteConfig$.pipe(switchMap((/**
* @param {?} rc
* @return {?}
*/
rc => zone.runOutsideAngular((/**
* @return {?}
*/
() => rc.fetchAndActivate()
.then((/**
* @return {?}
*/
() => rc.ensureInitialized()))
.then((/**
* @return {?}
*/
() => rc.getAll())))))), filterOutDefaults);
this.parameters = concat(default$, existing$, fresh$).pipe(scanToParametersArray(remoteConfig$), ɵkeepUnstableUntilFirstFactory(schedulers), shareReplay({ bufferSize: 1, refCount: true }));
this.changes = this.parameters.pipe(switchMap((/**
* @param {?} params
* @return {?}
*/
params => of(...params))), groupBy((/**
* @param {?} param
* @return {?}
*/
param => param.key)), mergeMap((/**
* @param {?} group
* @return {?}
*/
group => group.pipe(distinctUntilChanged()))));
this.strings = proxyAll(this.parameters, 'strings');
this.booleans = proxyAll(this.parameters, 'booleans');
this.numbers = proxyAll(this.parameters, 'numbers');
return ɵlazySDKProxy(this, loadedRemoteConfig$, zone);
}
}
AngularFireRemoteConfig.decorators = [
{ type: Injectable, args: [{
providedIn: 'any'
},] }
];
/** @nocollapse */
AngularFireRemoteConfig.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Inject, args: [FIREBASE_OPTIONS,] }] },
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FIREBASE_APP_NAME,] }] },
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [SETTINGS,] }] },
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DEFAULTS,] }] },
{ type: NgZone },
{ type: Object, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
];
/** @nocollapse */ AngularFireRemoteConfig.ɵprov = i0.ɵɵdefineInjectable({ factory: function AngularFireRemoteConfig_Factory() { return new AngularFireRemoteConfig(i0.ɵɵinject(i1.FIREBASE_OPTIONS), i0.ɵɵinject(i1.FIREBASE_APP_NAME, 8), i0.ɵɵinject(SETTINGS, 8), i0.ɵɵinject(DEFAULTS, 8), i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.PLATFORM_ID)); }, token: AngularFireRemoteConfig, providedIn: "any" });
if (false) {
/** @type {?} */
AngularFireRemoteConfig.prototype.changes;
/** @type {?} */
AngularFireRemoteConfig.prototype.parameters;
/** @type {?} */
AngularFireRemoteConfig.prototype.numbers;
/** @type {?} */
AngularFireRemoteConfig.prototype.booleans;
/** @type {?} */
AngularFireRemoteConfig.prototype.strings;
/**
* @type {?}
* @private
*/
AngularFireRemoteConfig.prototype.zone;
}
/** @type {?} */
export const budget = (/**
* @template T
* @param {?} interval
* @return {?}
*/
(interval) => (/**
* @param {?} source
* @return {?}
*/
(source) => new Observable((/**
* @param {?} observer
* @return {?}
*/
observer => {
/** @type {?} */
let timedOut = false;
// TODO use scheduler task rather than settimeout
/** @type {?} */
const timeout = setTimeout((/**
* @return {?}
*/
() => {
observer.complete();
timedOut = true;
}), interval);
return source.subscribe({
/**
* @param {?} val
* @return {?}
*/
next(val) {
if (!timedOut) {
observer.next(val);
}
},
/**
* @param {?} err
* @return {?}
*/
error(err) {
if (!timedOut) {
clearTimeout(timeout);
observer.error(err);
}
},
/**
* @return {?}
*/
complete() {
if (!timedOut) {
clearTimeout(timeout);
observer.complete();
}
}
});
}))));
/** @type {?} */
const typedMethod = (/**
* @param {?} it
* @return {?}
*/
(it) => {
switch (typeof it) {
case 'string':
return 'asString';
case 'boolean':
return 'asBoolean';
case 'number':
return 'asNumber';
default:
return 'asString';
}
});
const ɵ3 = typedMethod;
/**
* @template T
* @param {?=} to
* @return {?}
*/
export function scanToObject(to = 'strings') {
return pipe(
// TODO cleanup
scan((/**
* @param {?} c
* @param {?} p
* @return {?}
*/
(c, p) => (Object.assign(Object.assign({}, c), { [p.key]: typeof to === 'object' ?
p[typedMethod(to[p.key])]() :
p[AS_TO_FN[to]]() }))), typeof to === 'object' ?
(/** @type {?} */ (to)) :
(/** @type {?} */ ({}))), debounceTime(1), budget(10), distinctUntilChanged((/**
* @param {?} a
* @param {?} b
* @return {?}
*/
(a, b) => JSON.stringify(a) === JSON.stringify(b))));
}
/**
* @template T
* @param {?=} to
* @return {?}
*/
export function mapToObject(to = 'strings') {
return pipe(
// TODO this is getting a little long, cleanup
map((/**
* @param {?} params
* @return {?}
*/
(params) => params.reduce((/**
* @param {?} c
* @param {?} p
* @return {?}
*/
(c, p) => (Object.assign(Object.assign({}, c), { [p.key]: typeof to === 'object' ?
p[typedMethod(to[p.key])]() :
p[AS_TO_FN[to]]() }))), typeof to === 'object' ?
(/** @type {?} */ (to)) :
(/** @type {?} */ ({}))))), distinctUntilChanged((/**
* @param {?} a
* @param {?} b
* @return {?}
*/
(a, b) => JSON.stringify(a) === JSON.stringify(b))));
}
export { ɵ0, ɵ1, ɵ2, ɵ3 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-config.js","sourceRoot":"","sources":["../../../../src/remote-config/remote-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';\nimport { concat, EMPTY, MonoTypeOperatorFunction, Observable, of, OperatorFunction, pipe } from 'rxjs';\nimport {\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  groupBy,\n  map,\n  mergeMap,\n  observeOn,\n  scan,\n  shareReplay,\n  startWith,\n  switchMap,\n  tap,\n  withLatestFrom\n} from 'rxjs/operators';\nimport {\n  FIREBASE_APP_NAME,\n  FIREBASE_OPTIONS,\n  FirebaseAppConfig,\n  FirebaseOptions,\n  ɵAngularFireSchedulers,\n  ɵfirebaseAppFactory,\n  ɵkeepUnstableUntilFirstFactory,\n  ɵlazySDKProxy,\n  ɵPromiseProxy\n} from '@angular/fire';\nimport { remoteConfig } from 'firebase/app';\nimport { isPlatformBrowser } from '@angular/common';\n\nexport interface ConfigTemplate {\n  [key: string]: string | number | boolean;\n}\n\nexport const SETTINGS = new InjectionToken<remoteConfig.Settings>('angularfire2.remoteConfig.settings');\nexport const DEFAULTS = new InjectionToken<ConfigTemplate>('angularfire2.remoteConfig.defaultConfig');\n\nexport interface AngularFireRemoteConfig extends ɵPromiseProxy<remoteConfig.RemoteConfig> {\n}\n\nconst AS_TO_FN = { strings: 'asString', numbers: 'asNumber', booleans: 'asBoolean' };\nconst STATIC_VALUES = { numbers: 0, booleans: false, strings: undefined };\n\n// TODO look into the types here, I don't like the anys\nconst proxyAll = (observable: Observable<Parameter[]>, as: 'numbers' | 'booleans' | 'strings') => new Proxy(\n  observable.pipe(mapToObject(as as any)), {\n    get: (self, name: string) => self[name] || observable.pipe(\n      map(all => all.find(p => p.key === name)),\n      map(param => param ? param[AS_TO_FN[as]]() : STATIC_VALUES[as]),\n      distinctUntilChanged()\n    )\n  }\n) as any;\n\n// TODO export as implements Partial<...> so minor doesn't break us\nexport class Value implements remoteConfig.Value {\n  asBoolean() {\n    return ['1', 'true', 't', 'y', 'yes', 'on'].indexOf(this._value.toLowerCase()) > -1;\n  }\n\n  asString() {\n    return this._value;\n  }\n\n  asNumber() {\n    return Number(this._value) || 0;\n  }\n\n  getSource() {\n    return this._source;\n  }\n\n  // tslint:disable-next-line:variable-name\n  constructor(public _source: remoteConfig.ValueSource, public _value: string) {\n  }\n}\n\n// SEMVER use ConstructorParameters when we can support Typescript 3.6\nexport class Parameter extends Value {\n  constructor(public key: string, public fetchTimeMillis: number, source: remoteConfig.ValueSource, value: string) {\n    super(source, value);\n  }\n}\n\n// If it's a Parameter array, test any, else test the individual Parameter\nconst filterTest = (fn: (param: Parameter) => boolean) => filter<Parameter | Parameter[]>(it => Array.isArray(it) ? it.some(fn) : fn(it));\n\n// Allow the user to bypass the default values and wait till they get something from the server, even if it's a cached copy;\n// if used in conjuntion with first() it will only fetch RC values from the server if they aren't cached locally\nexport const filterRemote = () => filterTest(p => p.getSource() === 'remote');\n\n// filterFresh allows the developer to effectively set up a maximum cache time\nexport const filterFresh = (howRecentInMillis: number) => filterTest(p => p.fetchTimeMillis + howRecentInMillis >= new Date().getTime());\n\n\n// I ditched loading the defaults into RC and a simple map for scan since we already have our own defaults implementation.\n// The idea here being that if they have a default that never loads from the server, they will be able to tell via fetchTimeMillis\n// on the Parameter. Also if it doesn't come from the server it won't emit again in .changes, due to the distinctUntilChanged,\n// which we can simplify to === rather than deep comparison\nconst scanToParametersArray = (\n  remoteConfig: Observable<remoteConfig.RemoteConfig | undefined>\n): OperatorFunction<{ [key: string]: remoteConfig.Value }, Parameter[]> => pipe(\n  withLatestFrom(remoteConfig),\n  scan((existing, [all, rc]) => {\n    // SEMVER use \"new Set\" to unique once we're only targeting es6\n    // at the scale we expect remote config to be at, we probably won't see a performance hit from this unoptimized uniqueness\n    // implementation.\n    // const allKeys = [...new Set([...existing.map(p => p.key), ...Object.keys(all)])];\n    const allKeys = [...existing.map(p => p.key), ...Object.keys(all)].filter((v, i, a) => a.indexOf(v) === i);\n    return allKeys.map(key => {\n      const updatedValue = all[key];\n      return updatedValue ? new Parameter(key, rc ? rc.fetchTimeMillis : -1, updatedValue.getSource(), updatedValue.asString())\n        : existing.find(p => p.key === key);\n    });\n  }, [] as Array<Parameter>)\n);\n\n\n@Injectable({\n  providedIn: 'any'\n})\nexport class AngularFireRemoteConfig {\n\n  readonly changes: Observable<Parameter>;\n  readonly parameters: Observable<Parameter[]>;\n  readonly numbers: Observable<{ [key: string]: number | undefined }> & { [key: string]: Observable<number> };\n  readonly booleans: Observable<{ [key: string]: boolean | undefined }> & { [key: string]: Observable<boolean> };\n  readonly strings: Observable<{ [key: string]: string | undefined }> & { [key: string]: Observable<string | undefined> };\n\n  constructor(\n    @Inject(FIREBASE_OPTIONS) options: FirebaseOptions,\n    @Optional() @Inject(FIREBASE_APP_NAME) nameOrConfig: string | FirebaseAppConfig | null | undefined,\n    @Optional() @Inject(SETTINGS) settings: remoteConfig.Settings | null,\n    @Optional() @Inject(DEFAULTS) defaultConfig: ConfigTemplate | null,\n    private zone: NgZone,\n    // tslint:disable-next-line:ban-types\n    @Inject(PLATFORM_ID) platformId: Object\n  ) {\n\n    const schedulers = new ɵAngularFireSchedulers(zone);\n\n    const remoteConfig$ = of(undefined).pipe(\n      observeOn(schedulers.outsideAngular),\n      switchMap(() => isPlatformBrowser(platformId) ? import('firebase/remote-config') : EMPTY),\n      map(() => ɵfirebaseAppFactory(options, zone, nameOrConfig)),\n      map(app => app.remoteConfig()),\n      tap(rc => {\n        if (settings) {\n          rc.settings = settings;\n        }\n        if (defaultConfig) {\n          rc.defaultConfig = defaultConfig;\n        }\n      }),\n      // tslint:disable-next-line\n      startWith(undefined),\n      shareReplay({ bufferSize: 1, refCount: false })\n    );\n\n    const loadedRemoteConfig$ = remoteConfig$.pipe(\n      filter<remoteConfig.RemoteConfig>(rc => !!rc)\n    );\n\n    const default$: Observable<{ [key: string]: remoteConfig.Value }> = of(Object.keys(defaultConfig || {}).reduce(\n      (c, k) => ({ ...c, [k]: new Value('default', defaultConfig[k].toString()) }), {}\n    ));\n\n    // we should filter out the defaults we provided to RC, since we have our own implementation\n    // that gives us a -1 for fetchTimeMillis (so filterFresh can filter them out)\n    const filterOutDefaults = map<{ [key: string]: remoteConfig.Value }, { [key: string]: remoteConfig.Value }>(all =>\n      Object.keys(all)\n        .filter(key => all[key].getSource() !== 'default')\n        .reduce((acc, key) => ({ ...acc, [key]: all[key] }), {})\n    );\n\n    const existing$ = loadedRemoteConfig$.pipe(\n      switchMap(rc =>\n        rc.activate()\n          .then(() => rc.ensureInitialized())\n          .then(() => rc.getAll())\n      ),\n      filterOutDefaults\n    );\n\n    const fresh$ = loadedRemoteConfig$.pipe(\n      switchMap(rc => zone.runOutsideAngular(() =>\n        rc.fetchAndActivate()\n          .then(() => rc.ensureInitialized())\n          .then(() => rc.getAll())\n      )),\n      filterOutDefaults\n    );\n\n    this.parameters = concat(default$, existing$, fresh$).pipe(\n      scanToParametersArray(remoteConfig$),\n      ɵkeepUnstableUntilFirstFactory(schedulers),\n      shareReplay({ bufferSize: 1, refCount: true })\n    );\n\n    this.changes = this.parameters.pipe(\n      switchMap(params => of(...params)),\n      groupBy(param => param.key),\n      mergeMap(group => group.pipe(\n        distinctUntilChanged()\n      ))\n    );\n\n    this.strings = proxyAll(this.parameters, 'strings');\n    this.booleans = proxyAll(this.parameters, 'booleans');\n    this.numbers = proxyAll(this.parameters, 'numbers');\n\n    return ɵlazySDKProxy(this, loadedRemoteConfig$, zone);\n  }\n\n}\n\n\nexport const budget = <T>(interval: number): MonoTypeOperatorFunction<T> => (source: Observable<T>) => new Observable<T>(observer => {\n  let timedOut = false;\n  // TODO use scheduler task rather than settimeout\n  const timeout = setTimeout(() => {\n    observer.complete();\n    timedOut = true;\n  }, interval);\n  return source.subscribe({\n    next(val) {\n      if (!timedOut) {\n        observer.next(val);\n      }\n    },\n    error(err) {\n      if (!timedOut) {\n        clearTimeout(timeout);\n        observer.error(err);\n      }\n    },\n    complete() {\n      if (!timedOut) {\n        clearTimeout(timeout);\n        observer.complete();\n      }\n    }\n  });\n});\n\nconst typedMethod = (it: any) => {\n  switch (typeof it) {\n    case 'string':\n      return 'asString';\n    case 'boolean':\n      return 'asBoolean';\n    case 'number':\n      return 'asNumber';\n    default:\n      return 'asString';\n  }\n};\n\n\nexport function scanToObject(): OperatorFunction<Parameter, { [key: string]: string | undefined }>;\nexport function scanToObject(to: 'numbers'): OperatorFunction<Parameter, { [key: string]: number | undefined }>;\nexport function scanToObject(to: 'booleans'): OperatorFunction<Parameter, { [key: string]: boolean | undefined }>;\n// tslint:disable-next-line:unified-signatures\nexport function scanToObject(to: 'strings'): OperatorFunction<Parameter, { [key: string]: string | undefined }>;\nexport function scanToObject<T extends ConfigTemplate>(template: T): OperatorFunction<Parameter, T & { [key: string]: string | undefined }>;\nexport function scanToObject<T extends ConfigTemplate>(to: 'numbers' | 'booleans' | 'strings' | T = 'strings') {\n  return pipe(\n    // TODO cleanup\n    scan(\n      (c, p: Parameter) => ({\n        ...c, [p.key]: typeof to === 'object' ?\n          p[typedMethod(to[p.key])]() :\n          p[AS_TO_FN[to]]()\n      }),\n      typeof to === 'object' ?\n        to as T & { [key: string]: string | undefined } :\n        {} as { [key: string]: number | boolean | string }\n    ),\n    debounceTime(1),\n    budget(10),\n    distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b))\n  );\n}\n\nexport function mapToObject(): OperatorFunction<Parameter[], { [key: string]: string | undefined }>;\nexport function mapToObject(to: 'numbers'): OperatorFunction<Parameter[], { [key: string]: number | undefined }>;\nexport function mapToObject(to: 'booleans'): OperatorFunction<Parameter[], { [key: string]: boolean | undefined }>;\n// tslint:disable-next-line:unified-signatures\nexport function mapToObject(to: 'strings'): OperatorFunction<Parameter[], { [key: string]: string | undefined }>;\nexport function mapToObject<T extends ConfigTemplate>(template: T):\n  OperatorFunction<Parameter[], T & { [key: string]: string | undefined }>;\nexport function mapToObject<T extends ConfigTemplate>(to: 'numbers' | 'booleans' | 'strings' | T = 'strings') {\n  return pipe(\n    // TODO this is getting a little long, cleanup\n    map((params: Parameter[]) => params.reduce(\n      (c, p) => ({\n        ...c, [p.key]: typeof to === 'object' ?\n          p[typedMethod(to[p.key])]() :\n          p[AS_TO_FN[to]]()\n      }),\n      typeof to === 'object' ?\n        to as T & { [key: string]: string | undefined } :\n        {} as { [key: string]: number | boolean | string }\n    )),\n    distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b))\n  );\n}\n\n"]}