@angular/fire
Version:
The official library for Firebase and Angular
276 lines • 22.2 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { asyncScheduler, queueScheduler } from 'rxjs';
import { observeOn, subscribeOn, tap } from 'rxjs/operators';
/**
* @return {?}
*/
function noop() {
}
/**
* Schedules tasks so that they are invoked inside the Zone that is passed in the constructor.
*/
// tslint:disable-next-line:class-name
export class ɵZoneScheduler {
/**
* @param {?} zone
* @param {?=} delegate
*/
constructor(zone, delegate = queueScheduler) {
this.zone = zone;
this.delegate = delegate;
}
/**
* @return {?}
*/
now() {
return this.delegate.now();
}
/**
* @param {?} work
* @param {?=} delay
* @param {?=} state
* @return {?}
*/
schedule(work, delay, state) {
/** @type {?} */
const targetZone = this.zone;
// Wrap the specified work function to make sure that if nested scheduling takes place the
// work is executed in the correct zone
/** @type {?} */
const workInZone = (/**
* @this {?}
* @param {?} state
* @return {?}
*/
function (state) {
targetZone.runGuarded((/**
* @return {?}
*/
() => {
work.apply(this, [state]);
}));
});
// Scheduling itself needs to be run in zone to ensure setInterval calls for async scheduling are done
// inside the correct zone. This scheduler needs to schedule asynchronously always to ensure that
// firebase emissions are never synchronous. Specifying a delay causes issues with the queueScheduler delegate.
return this.delegate.schedule(workInZone, delay, state);
}
}
if (false) {
/**
* @type {?}
* @private
*/
ɵZoneScheduler.prototype.zone;
/**
* @type {?}
* @private
*/
ɵZoneScheduler.prototype.delegate;
}
// tslint:disable-next-line:class-name
/**
* @template T
*/
export class ɵBlockUntilFirstOperator {
/**
* @param {?} zone
*/
constructor(zone) {
this.zone = zone;
this.task = null;
}
/**
* @param {?} subscriber
* @param {?} source
* @return {?}
*/
call(subscriber, source) {
/** @type {?} */
const unscheduleTask = this.unscheduleTask.bind(this);
this.task = this.zone.run((/**
* @return {?}
*/
() => Zone.current.scheduleMacroTask('firebaseZoneBlock', noop, {}, noop, noop)));
return source.pipe(tap({ next: unscheduleTask, complete: unscheduleTask, error: unscheduleTask })).subscribe(subscriber).add(unscheduleTask);
}
/**
* @private
* @return {?}
*/
unscheduleTask() {
// maybe this is a race condition, invoke in a timeout
// hold for 10ms while I try to figure out what is going on
setTimeout((/**
* @return {?}
*/
() => {
if (this.task != null && this.task.state === 'scheduled') {
this.task.invoke();
this.task = null;
}
}), 10);
}
}
if (false) {
/**
* @type {?}
* @private
*/
ɵBlockUntilFirstOperator.prototype.task;
/**
* @type {?}
* @private
*/
ɵBlockUntilFirstOperator.prototype.zone;
}
// tslint:disable-next-line:class-name
export class ɵAngularFireSchedulers {
/**
* @param {?} ngZone
*/
constructor(ngZone) {
this.ngZone = ngZone;
this.outsideAngular = ngZone.runOutsideAngular((/**
* @return {?}
*/
() => new ɵZoneScheduler(Zone.current)));
this.insideAngular = ngZone.run((/**
* @return {?}
*/
() => new ɵZoneScheduler(Zone.current, asyncScheduler)));
}
}
if (false) {
/** @type {?} */
ɵAngularFireSchedulers.prototype.outsideAngular;
/** @type {?} */
ɵAngularFireSchedulers.prototype.insideAngular;
/** @type {?} */
ɵAngularFireSchedulers.prototype.ngZone;
}
/**
* Operator to block the zone until the first value has been emitted or the observable
* has completed/errored. This is used to make sure that universal waits until the first
* value from firebase but doesn't block the zone forever since the firebase subscription
* is still alive.
* @param {?} schedulers
* @return {?}
*/
export function ɵkeepUnstableUntilFirstFactory(schedulers) {
return (/**
* @template T
* @param {?} obs$
* @return {?}
*/
function keepUnstableUntilFirst(obs$) {
obs$ = obs$.lift(new ɵBlockUntilFirstOperator(schedulers.ngZone));
return obs$.pipe(
// Run the subscribe body outside of Angular (e.g. calling Firebase SDK to add a listener to a change event)
subscribeOn(schedulers.outsideAngular),
// Run operators inside the angular zone (e.g. side effects via tap())
observeOn(schedulers.insideAngular)
// INVESTIGATE https://github.com/angular/angularfire/pull/2315
// share()
);
});
}
// DEBUG quick debugger function for inline logging that typescript doesn't complain about
// wrote it for debugging the ɵlazySDKProxy, commenting out for now; should consider exposing a
// verbose mode for AngularFire in a future release that uses something like this in multiple places
// usage: () => log('something') || returnValue
// const log = (...args: any[]): false => { console.log(...args); return false }
// The problem here are things like ngOnDestroy are missing, then triggering the service
// rather than dig too far; I'm capturing these as I go.
/** @type {?} */
const noopFunctions = ['ngOnDestroy'];
// INVESTIGATE should we make the Proxy revokable and do some cleanup?
// right now it's fairly simple but I'm sure this will grow in complexity
/** @type {?} */
export const ɵlazySDKProxy = (/**
* @param {?} klass
* @param {?} observable
* @param {?} zone
* @return {?}
*/
(klass, observable, zone) => {
return new Proxy(klass, {
get: (/**
* @param {?} _
* @param {?} name
* @return {?}
*/
(_, name) => zone.runOutsideAngular((/**
* @return {?}
*/
() => {
if (klass[name]) {
return klass[name];
}
if (noopFunctions.includes(name)) {
return (/**
* @return {?}
*/
() => {
});
}
/** @type {?} */
const promise = observable.toPromise().then((/**
* @param {?} mod
* @return {?}
*/
mod => {
/** @type {?} */
const ret = mod && mod[name];
// TODO move to proper type guards
if (typeof ret === 'function') {
return ret.bind(mod);
}
else if (ret && ret.then) {
return ret.then((/**
* @param {?} res
* @return {?}
*/
(res) => zone.run((/**
* @return {?}
*/
() => res))));
}
else {
return zone.run((/**
* @return {?}
*/
() => ret));
}
}));
// recurse the proxy
return new Proxy((/**
* @return {?}
*/
() => undefined), {
get: (/**
* @param {?} _
* @param {?} name
* @return {?}
*/
(_, name) => promise[name]),
// TODO handle callbacks as transparently as I can
apply: (/**
* @param {?} self
* @param {?} _
* @param {?} args
* @return {?}
*/
(self, _, args) => promise.then((/**
* @param {?} it
* @return {?}
*/
it => it && it(...args))))
});
})))
});
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angularfire2.js","sourceRoot":"","sources":["../../../src/core/angularfire2.ts"],"names":[],"mappings":";;;;AACA,OAAO,EACL,cAAc,EAGd,cAAc,EAMf,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;;;;AAE7D,SAAS,IAAI;AACb,CAAC;;;;;AAMD,MAAM,OAAO,cAAc;;;;;IACzB,YAAoB,IAAS,EAAU,WAAgB,cAAc;QAAjD,SAAI,GAAJ,IAAI,CAAK;QAAU,aAAQ,GAAR,QAAQ,CAAsB;IACrE,CAAC;;;;IAED,GAAG;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IAC7B,CAAC;;;;;;;IAED,QAAQ,CAAC,IAAuD,EAAE,KAAc,EAAE,KAAW;;cACrF,UAAU,GAAG,IAAI,CAAC,IAAI;;;;cAGtB,UAAU;;;;;QAAG,UAAqC,KAAU;YAChE,UAAU,CAAC,UAAU;;;YAAC,GAAG,EAAE;gBACzB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5B,CAAC,EAAC,CAAC;QACL,CAAC,CAAA;QAED,sGAAsG;QACtG,iGAAiG;QACjG,+GAA+G;QAC/G,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAC1D,CAAC;CACF;;;;;;IAtBa,8BAAiB;;;;;IAAE,kCAAsC;;;;;;AAyBvE,MAAM,OAAO,wBAAwB;;;;IAGnC,YAAoB,IAAS;QAAT,SAAI,GAAJ,IAAI,CAAK;QAFrB,SAAI,GAAqB,IAAI,CAAC;IAGtC,CAAC;;;;;;IAED,IAAI,CAAC,UAAyB,EAAE,MAAqB;;cAC7C,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC;QACrD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG;;;QAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,EAAC,CAAC;QAE3G,OAAO,MAAM,CAAC,IAAI,CAChB,GAAG,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAC/E,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC9C,CAAC;;;;;IAEO,cAAc;QACpB,sDAAsD;QACtD,2DAA2D;QAC3D,UAAU;;;QAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,WAAW,EAAE;gBACxD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;aAClB;QACH,CAAC,GAAE,EAAE,CAAC,CAAC;IACT,CAAC;CACF;;;;;;IAxBC,wCAAsC;;;;;IAE1B,wCAAiB;;;AAyB/B,MAAM,OAAO,sBAAsB;;;;IAIjC,YAAmB,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;QAC/B,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,iBAAiB;;;QAAC,GAAG,EAAE,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAC,CAAC;QACvF,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,GAAG;;;QAAC,GAAG,EAAE,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,EAAC,CAAC;IAC1F,CAAC;CACF;;;IAPC,gDAA+C;;IAC/C,+CAA8C;;IAElC,wCAAqB;;;;;;;;;;AAYnC,MAAM,UAAU,8BAA8B,CAAC,UAAkC;IAC/E;;;;;IAAO,SAAS,sBAAsB,CAAI,IAAmB;QAC3D,IAAI,GAAG,IAAI,CAAC,IAAI,CACd,IAAI,wBAAwB,CAAC,UAAU,CAAC,MAAM,CAAC,CAChD,CAAC;QAEF,OAAO,IAAI,CAAC,IAAI;QACd,4GAA4G;QAC5G,WAAW,CAAC,UAAU,CAAC,cAAc,CAAC;QACtC,sEAAsE;QACtE,SAAS,CAAC,UAAU,CAAC,aAAa,CAAC;QACnC,+DAA+D;QAC/D,UAAU;SACX,CAAC;IACJ,CAAC,EAAC;AACJ,CAAC;;;;;;;;;MA0BK,aAAa,GAAG,CAAC,aAAa,CAAC;;;;AAIrC,MAAM,OAAO,aAAa;;;;;;AAAG,CAAC,KAAU,EAAE,UAA2B,EAAE,IAAY,EAAE,EAAE;IACrF,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE;QACtB,GAAG;;;;;QAAE,CAAC,CAAC,EAAE,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB;;;QAAC,GAAG,EAAE;YACpD,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE;gBACf,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;aACpB;YACD,IAAI,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBAChC;;;gBAAO,GAAG,EAAE;gBACZ,CAAC,EAAC;aACH;;kBACK,OAAO,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC,IAAI;;;;YAAC,GAAG,CAAC,EAAE;;sBAC1C,GAAG,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC;gBAC5B,kCAAkC;gBAClC,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE;oBAC7B,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBACtB;qBAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE;oBAC1B,OAAO,GAAG,CAAC,IAAI;;;;oBAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG;;;oBAAC,GAAG,EAAE,CAAC,GAAG,EAAC,EAAC,CAAC;iBACpD;qBAAM;oBACL,OAAO,IAAI,CAAC,GAAG;;;oBAAC,GAAG,EAAE,CAAC,GAAG,EAAC,CAAC;iBAC5B;YACH,CAAC,EAAC;YACF,oBAAoB;YACpB,OAAO,IAAI,KAAK;;;YAAC,GAAG,EAAE,CAAC,SAAS,GAAE;gBAC9B,GAAG;;;;;gBAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;;gBAE/B,KAAK;;;;;;gBAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI;;;;gBAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,EAAC,CAAA;aAChE,CACF,CAAC;QACJ,CAAC,EAAC,CAAA;KACH,CAAC,CAAC;AACL,CAAC,CAAA","sourcesContent":["import { NgZone } from '@angular/core';\nimport {\n  asyncScheduler,\n  Observable,\n  Operator,\n  queueScheduler,\n  SchedulerAction,\n  SchedulerLike,\n  Subscriber,\n  Subscription,\n  TeardownLogic\n} from 'rxjs';\nimport { observeOn, subscribeOn, tap } from 'rxjs/operators';\n\nfunction noop() {\n}\n\n/**\n * Schedules tasks so that they are invoked inside the Zone that is passed in the constructor.\n */\n// tslint:disable-next-line:class-name\nexport class ɵZoneScheduler implements SchedulerLike {\n  constructor(private zone: any, private delegate: any = queueScheduler) {\n  }\n\n  now() {\n    return this.delegate.now();\n  }\n\n  schedule(work: (this: SchedulerAction<any>, state?: any) => void, delay?: number, state?: any): Subscription {\n    const targetZone = this.zone;\n    // Wrap the specified work function to make sure that if nested scheduling takes place the\n    // work is executed in the correct zone\n    const workInZone = function(this: SchedulerAction<any>, state: any) {\n      targetZone.runGuarded(() => {\n        work.apply(this, [state]);\n      });\n    };\n\n    // Scheduling itself needs to be run in zone to ensure setInterval calls for async scheduling are done\n    // inside the correct zone. This scheduler needs to schedule asynchronously always to ensure that\n    // firebase emissions are never synchronous. Specifying a delay causes issues with the queueScheduler delegate.\n    return this.delegate.schedule(workInZone, delay, state);\n  }\n}\n\n// tslint:disable-next-line:class-name\nexport class ɵBlockUntilFirstOperator<T> implements Operator<T, T> {\n  private task: MacroTask | null = null;\n\n  constructor(private zone: any) {\n  }\n\n  call(subscriber: Subscriber<T>, source: Observable<T>): TeardownLogic {\n    const unscheduleTask = this.unscheduleTask.bind(this);\n    this.task = this.zone.run(() => Zone.current.scheduleMacroTask('firebaseZoneBlock', noop, {}, noop, noop));\n\n    return source.pipe(\n      tap({ next: unscheduleTask, complete: unscheduleTask, error: unscheduleTask })\n    ).subscribe(subscriber).add(unscheduleTask);\n  }\n\n  private unscheduleTask() {\n    // maybe this is a race condition, invoke in a timeout\n    // hold for 10ms while I try to figure out what is going on\n    setTimeout(() => {\n      if (this.task != null && this.task.state === 'scheduled') {\n        this.task.invoke();\n        this.task = null;\n      }\n    }, 10);\n  }\n}\n\n// tslint:disable-next-line:class-name\nexport class ɵAngularFireSchedulers {\n  public readonly outsideAngular: ɵZoneScheduler;\n  public readonly insideAngular: ɵZoneScheduler;\n\n  constructor(public ngZone: NgZone) {\n    this.outsideAngular = ngZone.runOutsideAngular(() => new ɵZoneScheduler(Zone.current));\n    this.insideAngular = ngZone.run(() => new ɵZoneScheduler(Zone.current, asyncScheduler));\n  }\n}\n\n/**\n * Operator to block the zone until the first value has been emitted or the observable\n * has completed/errored. This is used to make sure that universal waits until the first\n * value from firebase but doesn't block the zone forever since the firebase subscription\n * is still alive.\n */\nexport function ɵkeepUnstableUntilFirstFactory(schedulers: ɵAngularFireSchedulers) {\n  return function keepUnstableUntilFirst<T>(obs$: Observable<T>): Observable<T> {\n    obs$ = obs$.lift(\n      new ɵBlockUntilFirstOperator(schedulers.ngZone)\n    );\n\n    return obs$.pipe(\n      // Run the subscribe body outside of Angular (e.g. calling Firebase SDK to add a listener to a change event)\n      subscribeOn(schedulers.outsideAngular),\n      // Run operators inside the angular zone (e.g. side effects via tap())\n      observeOn(schedulers.insideAngular)\n      // INVESTIGATE https://github.com/angular/angularfire/pull/2315\n      // share()\n    );\n  };\n}\n\n// tslint:disable:ban-types\ntype FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];\ntype PromiseReturningFunctionPropertyNames<T> = {\n  [K in FunctionPropertyNames<T>]: ReturnType<T[K]> extends Promise<any> ? K : never\n}[FunctionPropertyNames<T>];\ntype NonPromiseReturningFunctionPropertyNames<T> = {\n  [K in FunctionPropertyNames<T>]: ReturnType<T[K]> extends Promise<any> ? never : K\n}[FunctionPropertyNames<T>];\ntype NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];\n// tslint:enable:ban-types\n\nexport type ɵPromiseProxy<T> = { [K in NonFunctionPropertyNames<T>]: Promise<T[K]> } &\n  { [K in NonPromiseReturningFunctionPropertyNames<T>]: (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>> } &\n  { [K in PromiseReturningFunctionPropertyNames<T>]: (...args: Parameters<T[K]>) => ReturnType<T[K]> };\n\n\n// DEBUG quick debugger function for inline logging that typescript doesn't complain about\n//       wrote it for debugging the ɵlazySDKProxy, commenting out for now; should consider exposing a\n//       verbose mode for AngularFire in a future release that uses something like this in multiple places\n//       usage: () => log('something') || returnValue\n// const log = (...args: any[]): false => { console.log(...args); return false }\n\n// The problem here are things like ngOnDestroy are missing, then triggering the service\n// rather than dig too far; I'm capturing these as I go.\nconst noopFunctions = ['ngOnDestroy'];\n\n// INVESTIGATE should we make the Proxy revokable and do some cleanup?\n//             right now it's fairly simple but I'm sure this will grow in complexity\nexport const ɵlazySDKProxy = (klass: any, observable: Observable<any>, zone: NgZone) => {\n  return new Proxy(klass, {\n    get: (_, name: string) => zone.runOutsideAngular(() => {\n      if (klass[name]) {\n        return klass[name];\n      }\n      if (noopFunctions.includes(name)) {\n        return () => {\n        };\n      }\n      const promise = observable.toPromise().then(mod => {\n        const ret = mod && mod[name];\n        // TODO move to proper type guards\n        if (typeof ret === 'function') {\n          return ret.bind(mod);\n        } else if (ret && ret.then) {\n          return ret.then((res: any) => zone.run(() => res));\n        } else {\n          return zone.run(() => ret);\n        }\n      });\n      // recurse the proxy\n      return new Proxy(() => undefined, {\n          get: (_, name) => promise[name],\n          // TODO handle callbacks as transparently as I can\n          apply: (self, _, args) => promise.then(it => it && it(...args))\n        }\n      );\n    })\n  });\n};\n"]}