@bespunky/angular-zen
Version:
The Angular tools you always wished were there.
420 lines • 77 kB
JavaScript
import { of, forkJoin, BehaviorSubject, EMPTY, animationFrames, interval } from 'rxjs';
import { delay, finalize, map, mapTo, materialize, switchMap, takeWhile, tap, startWith, filter } from 'rxjs/operators';
import { Directive, TemplateRef, ViewContainerRef } from '@angular/core';
import { Destroyable } from '../../destroyable/destroyable';
import { breakdownTime, durationToMs } from '../utils/time-utils';
import { OnObserverContext } from './types/on-observer-context';
import { ObserverCall } from './types/observer-call';
import { ViewRenderCommitment } from './types/view-render-commitment';
import * as i0 from "@angular/core";
/**
* The default number of times the countdown will be updated in a rendered view waiting to be auto-destroyed.
* To change this, the user will have to specify a value for the {@link OnObserverBaseDirective.countdownInterval `countdownInterval`} property.
**/
const DefaultCountdownUpdateCount = 30;
/**
* Provides functionality for `*onObserver<state>` directives that render templates according to the state of an observable.
*
* Any template assigned with the directive will render when the defined observer calls are intercepted, and destroyed when any other calls are
* intercepted. For example, if the directive intercepts `next` calls, the view will render on the first value emission, then destroy on
* `complete` or `error`.
*
* ## Features
*
* #### View Context
* Use the microsyntax `as` keyword to assign resolved values to a variable.
* Use the microsyntax `let` keyword to assign the {@link OnObserverContext full context object} to a variable (e.g. `let context`).
*
* #### Delayed rendering
* Specify a value for {@link OnObserverBaseDirective.showAfter `showAfter`} to delay rendering.
*
* #### Auto destroy
* Specify {@link OnObserverBaseDirective.showFor `showFor`} to automatically destroy the view after a certain duration.
*
* #### Countdown updates
* When {@link OnObserverBaseDirective.showFor `showFor`} is specified, the view context will be updated with the time remaining until the view
* is destroyed and the time elapsed since it was rendered. This allows giving the user feedback in a progress bar, a spinner, a textual timer
* or any other UI component.
*
* Remaining is provided by the {@link OnObserverContext.remaining `remaining`} property. Elapsed time is provided by the {@link OnObserverContext.elapsed `elapsed`}
* property. Access it by assigning a variable using `let`, like so:
* `let remaining = remaining`
*
* #### Multi view mode
* Specify {@link OnObserverBaseDirective.viewMode `viewMode = 'multiple'`} to enable rendering a new view for each intercepted call
* instead of updating a single rendered view. This allows stacking logs, notification snackbars, or any other aggregation functionality.
* Combined with {@link OnObserverBaseDirective.showFor `showFor`}, this is great for disappearing messages/notifications.
*
* #### View index
* In multi-view mode, the context will contain the index of the view, which can be used for calculations and styling.
*
* #### Multi call interception
* Create different interception combinations by specifying more than one call name in {@link OnObserverBaseDirective.renderOnCallsTo `renderOnCallsTo`}.
* This allows, for example, the combination of `'error'` and `'complete'` to create a directive named `*onObserverFinalized`.
*
* ## Extending
* As this base class doesn't know what the properties of the extending class will be, extending classes must:
* 1. Define their selector in the abstract {@link OnObserverBaseDirective.selector `selector`} property. This will allow the directive to
* assign the view context with a property which will enable the microsyntax `as` keyword.
* 2. Define the call(s) to intercept and render the view for in the abstract {@link OnObserverBaseDirective.renderOnCallsTo `renderOnCallsTo`}.
* 3. Define an `@Input() set <selector>` property which will call `this.input.next(value)`.
* 4. Define an `@Input() set <selector>ViewMode` property which will set `this.viewMode`.
* 5. Define an `@Input() set <selector>ShowAfter` property which will set `this.showAfter`.
* 6. Define an `@Input() set <selector>ShowFor` property which will set `this.showFor`.
* 7. Define an `@Input() set <selector>CountdownInterval` property which will set `this.countdownInterval`.
* 8. Define this static context type guard to allow strong typing the template:
* ```ts
* static ngTemplateContextGuard<T>(directive: ___DIRECTIVE_NAME___<T>, context: unknown): context is OnObserverContext<T>
* { return true; }
* ```
*
* @export
* @abstract
* @class OnObserverBaseDirective
* @extends {Destroyable}
* @implements {OnInit}
* @template T The type of value the observable will emit.
*/
export class OnObserverBaseDirective extends Destroyable {
constructor(template, viewContainer) {
super();
this.template = template;
this.viewContainer = viewContainer;
/**
* A global commitment map holding all commitments to render for which the directive has created commitment observables.
* Ids are the timestamp of the observed calls and values are the commitments with their rendering parameters.
*
* @private
* @type {RenderCommitmentMap<T>}
*/
this.commitments = new Map();
/**
* (Optional) The view mode the directive will operate in:
* `'single'` - A single view will be rendered on intercepted calls. If a view has already been rendered when a call is intercepted,
* the existing view will be updated with data from the new call.
*
* `'multiple'` - Every new intercepted call will render a new view with its own context and data encapsulated from the current call.
*
* Default is `'single'`.
*
* ⚠️ Extending classes should:
* 1. Declare an `@Input()` setter named `{selector}ViewMode` (e.g. onObserverCompleteViewMode) which will set this value.
* 2. Provide the above documentation for the setter property.
*
* @default 'single'
* @protected
* @type {ViewMode}
*/
this.viewMode = 'single';
/**
* (Optional) The duration for which the directive should wait before rendering the view once an intercepted call is made.
*
* You can specify a number, which will be treated as milliseconds, or a string with the format of `<number><ms | s | ms>`.
* Numbers can be either integers or floats.
* For example:
* - `3000` - Wait for 3 seconds, then render the view.
* - `'10s'` - Wait for 10 seconds, then render the view.
* - `'0.5m'` - Wait for 30 seconds, then render the view.
* - `'100ms'` - Wait for 100 milliseconds, then render the view.
*
* Default is `0`, meaning immediately render the view.
*
* TODO: ADD LINK TO TOUR OR FULL WIKI PAGE
* Read more {@link OnObserverBaseDirective About render flow}.
*
* ⚠️ Extending classes should:
* 1. Declare an `@Input()` setter named `{selector}ShowAfter` (e.g. onObserverCompleteShowAfter) which will set this value.
* 2. Provide the above documentation for the setter property.
*
* @protected
* @type {DurationAnnotation}
*/
this.showAfter = 0;
/**
* ### Why BehaviorSubject<... | null> and not Subject<...>
* `input` is set from @Input properties. For some reason, Angular passes-in the first value BEFORE
* ngOnInit, even though other @Input properties (e.g. showAfter, showFor) are passed AFTER ngOnInit.
* If subscription occurs in the constructor, `input` will emit the first observable too fast, which
* might lead to pipes breaking or misbehaving if they rely on properties to be instantiated first.
*
* This leads to subscribing in ngOnInit, to allow Angular time to initialize those.
* BUT, if `input` is a Subject, as the first value was already emitted BEFORE ngOnInit, it will not be
* captured by our subscription to `input`. Hence the BehaviorSubject - To allow capturing that first observable.
*/
this.input = new BehaviorSubject(null);
}
/**
* The first commitment in the {@link OnObserverBaseDirective.commitments global commitments map}. Used when working with a single view
* to retrieve its corresponding single commitment.
*
* @readonly
* @private
* @type {ViewRenderCommitment<T> | undefined}
*/
get mainCommitment() { return this.commitments.values().next().value; }
/**
* `true` if {@link OnObserverBaseDirective.viewMode viewMode} is `'single'`; otherwise, `false`.
*
* @readonly
* @type {boolean}
*/
get isSingleView() { return this.viewMode === 'single'; }
/**
* `true` if {@link OnObserverBaseDirective.viewMode viewMode} is `'multiple'`; otherwise, `false`.
*
* @readonly
* @type {boolean}
*/
get isMultiView() { return this.viewMode === 'multiple'; }
ngOnInit() {
// See `this.input` documentation for why subscription is done in ngOnInit.
this.subscribe(this.renderFeed());
}
/**
* Destroys any rendered view.
*
* @private
*/
destroyAll() {
this.commitments.forEach(({ view }) => view?.destroy());
}
/**
* Creates the main feed the directive will subscribe to. The feed will listen to changed to {@link OnObserverBaseDirective.input `input`},
* then switch to the newly received observable in order to start observing it.
* The newly received observable will then be materialized and calls will be aggregated as commitment objects with information about
* what to render and when. Those commitments will pass through the {@link OnObserverBaseDirective.onCommitmentsChanged onCommitmentsChanged()} method
* which will update the global commitment and create observables with commitments to render and auto destroy views according to the
* given commitments.
*
* This feed is the single reactive entrypoint, meaning any observable created by the directive will be created inside of this
* observable or its nested observables. Any time a nested observable is created it will be switched to. This allows the pipeline to
* completely startover when a new call is made or a new {@link OnObserverBaseDirective.input `input`} observable is provided, thus keeping
* a consistent stream of data to the {@link OnObserverBaseDirective.commitments global commitments map}.
*
* @private
* @return {Observable<ViewRenderCommitment<T>[]>} An observable as described above.
*/
renderFeed() {
return this.input.pipe(
// Make sure views are reset if a new observable is passed-in to the directive
tap(() => this.destroyAll()),
// Free memory once the directive is destroyed and the subscription closed
// TODO: Will this actually execute? `this.subscribe()` doesn't complete the observable but unsubscribes on component destruction
finalize(() => this.destroyAll()), switchMap(input => input ? this.observeInput(input) : EMPTY), map(call => this.shouldRender(call) ? this.aggregateCommitments(call) : this.deaggregateCommitments()), switchMap(commitments => this.onCommitmentsChanged(commitments)));
}
/**
* Materializes the observable and converts notifications to an {@link ObserverCall} object.
* The returned observable will always start with a `'resolving'` call.
*
* @private
* @param {Observable<T>} input The observable to watch.
* @return {Observable<ObserverCall<T>>} A materialized observable which describes each observable notification as an {@link ObserverCall} object.
*/
observeInput(input) {
return input.pipe(materialize(), map(ObserverCall.fromNotification), startWith(ObserverCall.resolving()));
}
/**
* Checks whether the given observer call should be rendered according to the interception config in {@link OnObserverBaseDirective.renderOnCallsTo renderOnCallsTo}.
*
* @private
* @param {ObserverCall<T>} The call to check.
* @return {boolean} `true` if the call should be rendered; otherwise `false`.
*/
shouldRender({ name }) {
const observeOn = Array.isArray(this.renderOnCallsTo) ? this.renderOnCallsTo : [this.renderOnCallsTo];
return observeOn.includes(name);
}
/**
* Creates the new commitments map when a new commitment should render.
*
* When `viewMode` is `'single'` the map will always contain a single commitment. If the commitment hasn't been rendered yet, a new commitment will be created.
* Otherwise, the existing commitment will be replaced by a clone with updated parameters (i.e. delay and countdown).
*
* When `viewMode` is `'multiple'` a new commitment will always be added to the map.
*
* @private
* @param {ObserverCall<T>} call The new call which should render.
* @return {RenderCommitmentMap<T>} The new map of commitments to render.
*/
aggregateCommitments(call) {
const commitments = this.commitments;
// In single-view mode, if there's already a commitment, we'll replace it with a new one. Otherwise, we'll create a fresh one.
const newCommitment = this.isSingleView && this.mainCommitment
? ViewRenderCommitment.update(this.mainCommitment, call)
: ViewRenderCommitment.create(call, durationToMs(this.showAfter), durationToMs(this.showFor || 0));
return new Map(commitments.set(newCommitment.commitmentId, newCommitment));
}
/**
* Creates the new commitments map when a new commitment shouldn't render.
*
* @private
* @return {RenderCommitmentMap<T>} If `showFor` is specified, meaning views should be auto destroyed after a certain duration,
* the current commitments will kept alive by returning them as a new map. This will allow recommiting to the same render parameters (i.e. delay and countdown).
* Otherwise, when views should destroy immediately, an empty map will be returned.
*/
deaggregateCommitments() {
return this.showFor ? new Map(this.commitments) : new Map();
}
/**
* Handles the changes to the current commitment of the watched observable and creates and commits to render all commitments.
*
* This will update the global commitment map. If an empty map is passed, all previous commitments will be destroyed.
*
* @private
* @param {RenderCommitmentMap<T>} commitments The current commitment map.
* @return {Observable<ViewRenderCommitment<T>[]>} An observable joining all render commitments.
*/
onCommitmentsChanged(commitments) {
// If the commitment map has been reset, destroy any previously rendered view
if (!commitments.size)
this.destroyAll();
// Update the global commitment map
this.commitments = commitments;
// Map all commitments to a commitment to render observable
const runCommitments = Array.from(commitments.keys())
.map((commitmentId, index) => this.commitToRender(commitments, commitmentId, index));
return forkJoin(runCommitments);
}
/**
* Creates an observable that initiates the render flow for an emission. Render flow is as follows:
* 1. Delay render until the time for render (i.e. {@link ViewRenderCommitment.renderAt}) has come.
* 2. Render the view.
* 3. Update the {@link OnObserverBaseDirective.commitments global commitments map} with the rendered commitment.
* 4. Initiate an auto destroy timer. See {@link OnObserverBaseDirective.autoDestroy autoDestroy()}.
* 5. Remove the destroyed commitment from the {@link OnObserverBaseDirective.commitments global commitments map}.
*
* @private
* @param {RenderCommitmentMap<T>} commitments The current commitment map holding all commitments to render.
* @param {string} commitmentId The id of the commitment to render.
* @param {number} index The index of the view to be rendered.
* @return {Observable<ViewRenderCommitment<T>>} An observable that initiates the render flow for an emission.
*/
commitToRender(commitments, commitmentId, index) {
if (!commitments.has(commitmentId))
throw new Error(`
*${this.selector} has encountered an inconsistency issue. Tried to commit to rendering commitment with ID ${commitmentId}, but no commitment object exists with that ID.
Please consider filing an issue and providing a stack trace here: https://github.com/BeSpunky/angular-zen/issues/new?assignees=BeSpunky&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=%F0%9F%90%9B+
`);
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
return of(commitments.get(commitmentId)).pipe(switchMap(commitment => this.delayRender(commitment)),
// Actually perform rendering (or update the view if already rendered)
switchMap(commitment => this.renderCommitment(commitment, index)),
// The commitment returned from `renderCommitment()` now contains the view, so update the global map
tap(renderedCommitment => commitments.set(commitmentId, renderedCommitment)),
// Initiate the auto-destroy mechanism (will skip if `showFor` wasn't specified)
switchMap(renderedCommitment => this.autoDestroy(renderedCommitment)),
// Commitment has completed successfully. Remove it from the global map.
tap(renderedCommitment => renderedCommitment.autoDestroys ? commitments.delete(commitmentId) : void 0));
}
/**
* Creates an observable which delays the pipeline until the time to render the view (i.e. {@link ViewRenderCommitment.renderAt}) comes.
*
* @private
* @param {ViewRenderCommitment<T>} commitment The commitment to delay.
* @return {Observable<ViewRenderCommitment<T>>} An observable which delays the pipeline until the time to render the view (i.e. {@link ViewRenderCommitment.renderAt}) comes.
*/
delayRender(commitment) {
return of(commitment).pipe(delay(new Date(commitment.renderAt)));
}
/**
* Creates a new context for the given commitment and renders (or updates) the view.
*
* @private
* @param {ViewRenderCommitment<T>} commitment The commitment for which to create the context and render the view.
* @param {number} index The index of the view. If `viewMode` is `'single'` this should always be `0` as there is only one view.
* @return {Observable<ViewRenderCommitment<T>>} An observable which renderes the commitment, then emits a new updated commitment referencing the rendered view.
*/
renderCommitment(commitment, index) {
const context = OnObserverContext.fromCommitment(this.selector, index, commitment);
const renderedCommitment = this.renderOrUpdateView(commitment, context);
return of(renderedCommitment);
}
/**
* Creates an interval observable which counts down until the time to destroy the view is reached, then destroys the view.
* While the timer is running, the rendered view's context will be updated in fixed intervals with the time left before destruction.
*
* @see {@link OnObserverBaseDirective.defineCountdownInterval defineCountdownInterval()} for more about the fixed countdown interval.
*
* If {@link OnObserverBaseDirective.countdownInterval `countdownInterval`} is `'animationFrames'`, the rxjs `animationFrames()` function
* will be used instead of the interval.
*
* @private
* @param {ViewRenderCommitment<T>} commitment The rendered commitment for which to initiate auto destroy.
* @return {Observable<ViewRenderCommitment<T>>} A timer observable which counts down until the time to destroy the view is reached, then destroys the view, while
* updating the context with the time left for destruction. The observable will emit the commitment
*/
autoDestroy(commitment) {
const { destroyAt, view } = commitment;
if (!(destroyAt && view))
return of(commitment);
const countdownInterval = this.defineCountdownInterval();
const countdown = countdownInterval === 'animationFrames' ? animationFrames() : interval(countdownInterval);
return countdown.pipe(map(() => destroyAt - Date.now()), map(timeLeftMs => [timeLeftMs < 0 ? 0 : timeLeftMs, commitment.showFor - timeLeftMs]), tap(([timeLeftMs, elapsedTimeMs]) => this.updateViewContextCountdown(view, timeLeftMs, elapsedTimeMs)), takeWhile(([timeLeftMs]) => timeLeftMs > 0, true), filter(([timeLeftMs]) => timeLeftMs <= 0), tap(() => view.destroy()), mapTo(commitment));
}
/**
* Makes sure the specified commitment is rendered and its context is updated, then returns an updated commitment with the rendered (or updated) view.
* If the view has been previously rendered, its context will be updated. Otherwise, the view will be rendered for the first time.
*
* The new commitment will be used further down the pipeline to update the internal `commitments` map.
*
* @see {@link OnObserverBaseDirective.commitToRender `commitToRender()`}.
*
* @private
* @param {ViewRenderCommitment<T>} commitment The commitment for which the view should be rendered.countdown
* @param {OnObserverContext<T>} context The context object to feed into the view.
* @return {ViewRenderCommitment<T>} The new commitment containing the rendered (or updated) view.
*/
renderOrUpdateView(commitment, context) {
if (commitment.view) {
commitment.view.context = context;
return ViewRenderCommitment.rendered(commitment, commitment.view);
}
return ViewRenderCommitment.rendered(commitment, this.viewContainer.createEmbeddedView(this.template, context));
}
/**
* Breaks down the time left before the view is destroyed to its parts and updates the view context so that the user may present
* a countdown or any other UI component indicating when the view will be destroyed.
*
* @private
* @param {RenderedView<T>} view The view in which to update the countdown.
* @param {number} timeLeftMs The time left (in milliseconds) for the view before being destroyed.
* @param {number} timeElapsedMs The time elapsed (in milliseconds) from the moment the view was rendered.
*/
updateViewContextCountdown(view, timeLeftMs, timeElapsedMs) {
const remaining = breakdownTime(timeLeftMs);
const elapsed = breakdownTime(timeElapsedMs);
const { $implicit, call, index } = view.context;
// TODO: Remove the `showingFor` argument when launching v6.0.0
view.context = new OnObserverContext(this.selector, index, call, $implicit, remaining, remaining, elapsed);
}
/**
* Defines the interval (in milliseconds) with which countdown updates should be made to the view's context.
* If the user has defined a value through {@link OnObserverBaseDirective.countdownInterval `countdownInterval`}, that value will be used.
* If the user has defined `'animationFrames'` as the value for {@link OnObserverBaseDirective.countdownInterval `countdownInterval`}, this will return `'animationFrames'`.
* Otherwise, {@link OnObserverBaseDirective.showFor `showFor`} will be divided by a fixed number defined by {@link DefaultCountdownUpdateCount `DefaultCountdownUpdateCount`}, currently 30, meaning the user will get
* 30 countdown updates with fixed intervals between them before the view is destroyed.
*
* @private
* @return {number} The interval with which countdown updates should be made to the view's context.
*/
defineCountdownInterval() {
// If the view should persist, or it should auto-destroy but percision has been manually specified, do nothing
if (!this.showFor)
throw new Error(`
Auto-destroy countdown seems to have been initiated when 'showFor' hasn't been set. This shouldn't have happend.
Please consider filing an issue and providing a stack trace here: https://github.com/BeSpunky/angular-zen/issues/new?assignees=BeSpunky&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=%F0%9F%90%9B+
`);
if (this.countdownInterval === 'animationFrames')
return 'animationFrames';
if (this.countdownInterval)
return durationToMs(this.countdownInterval);
const showForMs = durationToMs(this.showFor);
return showForMs / DefaultCountdownUpdateCount;
}
}
OnObserverBaseDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: OnObserverBaseDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
OnObserverBaseDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: OnObserverBaseDirective, usesInheritance: true, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: OnObserverBaseDirective, decorators: [{
type: Directive
}], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"on-observer-base.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/angular-zen/core/src/rxjs/on-observer/abstraction/on-observer-base.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, of, forkJoin, BehaviorSubject, EMPTY, animationFrames, interval            } from 'rxjs';\nimport { delay, finalize, map, mapTo, materialize, switchMap, takeWhile, tap, startWith, filter } from 'rxjs/operators';\nimport { Directive, OnInit, TemplateRef, ViewContainerRef                                       } from '@angular/core';\n\nimport { Destroyable                                                                            } from '../../destroyable/destroyable';\nimport { ObserverName, DurationAnnotation, RenderCommitmentMap, ViewMode, RenderedView          } from '../abstraction/types/general';\nimport { breakdownTime, durationToMs                                                            } from '../utils/time-utils';\nimport { OnObserverContext                                                                      } from './types/on-observer-context';\nimport { ObserverCall                                                                           } from './types/observer-call';\nimport { ViewRenderCommitment                                                                   } from './types/view-render-commitment';\n\n/**\n * The default number of times the countdown will be updated in a rendered view waiting to be auto-destroyed.\n * To change this, the user will have to specify a value for the {@link OnObserverBaseDirective.countdownInterval `countdownInterval`} property.\n **/\nconst DefaultCountdownUpdateCount = 30;\n\n/**\n * Provides functionality for `*onObserver<state>` directives that render templates according to the state of an observable.\n * \n * Any template assigned with the directive will render when the defined observer calls are intercepted, and destroyed when any other calls are\n * intercepted. For example, if the directive intercepts `next` calls, the view will render on the first value emission, then destroy on\n * `complete` or `error`.\n * \n * ## Features\n * \n * #### View Context\n * Use the microsyntax `as` keyword to assign resolved values to a variable.\n * Use the microsyntax `let` keyword to assign the {@link OnObserverContext full context object} to a variable (e.g. `let context`).\n *  \n * #### Delayed rendering\n * Specify a value for {@link OnObserverBaseDirective.showAfter `showAfter`} to delay rendering.\n * \n * #### Auto destroy\n * Specify {@link OnObserverBaseDirective.showFor `showFor`} to automatically destroy the view after a certain duration.\n * \n * #### Countdown updates\n * When {@link OnObserverBaseDirective.showFor `showFor`} is specified, the view context will be updated with the time remaining until the view\n * is destroyed and the time elapsed since it was rendered. This allows giving the user feedback in a progress bar, a spinner, a textual timer\n * or any other UI component. \n * \n * Remaining is provided by the {@link OnObserverContext.remaining `remaining`} property. Elapsed time is provided by the {@link OnObserverContext.elapsed `elapsed`}\n * property. Access it by assigning a variable using `let`, like so:  \n * `let remaining = remaining`\n * \n * #### Multi view mode\n * Specify {@link OnObserverBaseDirective.viewMode `viewMode = 'multiple'`} to enable rendering a new view for each intercepted call\n * instead of updating a single rendered view. This allows stacking logs, notification snackbars, or any other aggregation functionality.\n * Combined with {@link OnObserverBaseDirective.showFor `showFor`}, this is great for disappearing messages/notifications.\n * \n * #### View index\n * In multi-view mode, the context will contain the index of the view, which can be used for calculations and styling.\n *\n * #### Multi call interception\n * Create different interception combinations by specifying more than one call name in {@link OnObserverBaseDirective.renderOnCallsTo `renderOnCallsTo`}.\n * This allows, for example, the combination of `'error'` and `'complete'` to create a directive named `*onObserverFinalized`.\n * \n * ## Extending\n * As this base class doesn't know what the properties of the extending class will be, extending classes must:\n * 1. Define their selector in the abstract {@link OnObserverBaseDirective.selector `selector`} property. This will allow the directive to\n * assign the view context with a property which will enable the microsyntax `as` keyword.\n * 2. Define the call(s) to intercept and render the view for in the abstract {@link OnObserverBaseDirective.renderOnCallsTo `renderOnCallsTo`}.\n * 3. Define an `@Input() set <selector>` property which will call `this.input.next(value)`.\n * 4. Define an `@Input() set <selector>ViewMode` property which will set `this.viewMode`.\n * 5. Define an `@Input() set <selector>ShowAfter` property which will set `this.showAfter`.\n * 6. Define an `@Input() set <selector>ShowFor` property which will set `this.showFor`.\n * 7. Define an `@Input() set <selector>CountdownInterval` property which will set `this.countdownInterval`.\n * 8. Define this static context type guard to allow strong typing the template:\n * ```ts\n * static ngTemplateContextGuard<T>(directive: ___DIRECTIVE_NAME___<T>, context: unknown): context is OnObserverContext<T>\n * { return true; }\n * ```\n * \n * @export\n * @abstract\n * @class OnObserverBaseDirective\n * @extends {Destroyable}\n * @implements {OnInit}\n * @template T The type of value the observable will emit.\n */\n@Directive()\nexport abstract class OnObserverBaseDirective<T> extends Destroyable implements OnInit\n{\n    /**\n     * A global commitment map holding all commitments to render for which the directive has created commitment observables.\n     * Ids are the timestamp of the observed calls and values are the commitments with their rendering parameters.\n     *\n     * @private\n     * @type {RenderCommitmentMap<T>}\n     */\n    private commitments: RenderCommitmentMap<T> = new Map();\n\n    /**\n     * The first commitment in the {@link OnObserverBaseDirective.commitments global commitments map}. Used when working with a single view\n     * to retrieve its corresponding single commitment.\n     *\n     * @readonly\n     * @private\n     * @type {ViewRenderCommitment<T> | undefined}\n     */\n    private get mainCommitment(): ViewRenderCommitment<T> | undefined { return this.commitments.values().next().value; }\n\n    /**\n     * The selector defined for the directive extending this class. Will be used to create a corresponding\n     * property in the view context in order to make the micro-syntax `as` keyword work.\n     *\n     * @protected\n     * @abstract\n     * @type {string}\n     */\n    protected abstract readonly selector: string;\n    /**\n     * The observer name(s) for which to intercept calls.\n     *\n     * @protected\n     * @abstract\n     * @type {(ObserverName | ObserverName[])}\n     */\n    protected abstract renderOnCallsTo  : ObserverName | ObserverName[];\n    \n    /**\n     * (Optional) The view mode the directive will operate in:  \n     * `'single'` - A single view will be rendered on intercepted calls. If a view has already been rendered when a call is intercepted,\n     * the existing view will be updated with data from the new call.\n     * \n     * `'multiple'` - Every new intercepted call will render a new view with its own context and data encapsulated from the current call.\n     * \n     * Default is `'single'`.\n     * \n     * ⚠️ Extending classes should:\n     * 1. Declare an `@Input()` setter named `{selector}ViewMode` (e.g. onObserverCompleteViewMode) which will set this value.\n     * 2. Provide the above documentation for the setter property.\n     *\n     * @default 'single'\n     * @protected\n     * @type {ViewMode}\n     */\n    protected viewMode          : ViewMode           = 'single';\n    /**\n     * (Optional) The duration for which the directive should wait before rendering the view once an intercepted call is made.\n     * \n     * You can specify a number, which will be treated as milliseconds, or a string with the format of `<number><ms | s | ms>`.\n     * Numbers can be either integers or floats.\n     * For example:\n     * - `3000` - Wait for 3 seconds, then render the view.\n     * - `'10s'` - Wait for 10 seconds, then render the view.\n     * - `'0.5m'` - Wait for 30 seconds, then render the view.\n     * - `'100ms'` - Wait for 100 milliseconds, then render the view.\n     * \n     * Default is `0`, meaning immediately render the view.\n     *\n     * TODO: ADD LINK TO TOUR OR FULL WIKI PAGE\n     * Read more {@link OnObserverBaseDirective About render flow}.\n     * \n     * ⚠️ Extending classes should:\n     * 1. Declare an `@Input()` setter named `{selector}ShowAfter` (e.g. onObserverCompleteShowAfter) which will set this value.\n     * 2. Provide the above documentation for the setter property.\n     * \n     * @protected\n     * @type {DurationAnnotation}\n     */\n    protected showAfter         : DurationAnnotation = 0;\n    /**\n     * (Optional) The duration for which the view should be rendered. When the duration passes, the view will be auto destroyed.\n     *\n     * You can specify a number, which will be treated as milliseconds, or a string with the format of `<number><ms | s | ms>`.\n     * Numbers can be either integers or floats.\n     * For example:\n     * - `3000` - The view will be destroyed after 3 seconds.\n     * - `'10s'` - The view will be destroyed after 10 seconds.\n     * - `'0.5m'` - The view will be destroyed after 30 seconds.\n     * - `'100ms'` - The view will be destroyed after 100 milliseconds.\n     * \n     * During the time the view is rendered, the context will be updated with a countdown object to facilitate any UI part used to\n     * indicate countdown to the user. The countdown will be exposed through the {@link OnObserverContext.remaining `remaining`}\n     * property and the elapsed time through {@link OnObserverContext.elapsed `elapsed`} property in the view context and can both\n     * be accessed be declaring a `let` variable (e.g. `let remaining = remaining`).\n     * See {@link OnObserverBaseDirective.countdownInterval `countdownInterval`} for changing the updates interval.\n     * \n     * When unspecified, the view will be destroyed immediately once the observer detects a call different to the intercepted ones.\n     * \n     * TODO: ADD LINK TO TOUR OR FULL WIKI PAGE\n     * Read more {@link OnObserverBaseDirective About render flow}.\n     * \n     * ⚠️ Extending classes should:\n     * 1. Declare an `@Input()` setter named `{selector}ShowFor` (e.g. onObserverCompleteShowFor) which will set this value.\n     * 2. Provide the above documentation for the setter property.\n     *\n     * @protected\n     * @type {DurationAnnotation}\n     */\n    protected showFor?          : DurationAnnotation;\n    /**\n     * ### Only used when passing a value to {@link OnObserverBaseDirective.showFor `showFor`}.\n     * \n     * (Optional) The interval with which countdown updates should be made to the view's context before it auto destroys.\n     * The lower the value, the more updates will be made to the context, but the more resources your directive will consume.\n     * \n     * You can specify a number, which will be treated as milliseconds, or a string with the format of `<number><ms | s | ms>`.\n     * Numbers can be either integers or floats.\n     * For example:\n     * - `3000` - 3 seconds between each update.\n     * - `'10s'` - 10 seconds between each update.\n     * - `'0.5m'` - 30 seconds between each update.\n     * - `'100ms'` - 100 milliseconds between each update.\n     * \n     * You can also specify `'animationFrames'` so the countdown gets updated each time the browser is working on animations.\n     * \n     * When unspecified, the total duration of the countdown will be divided by {@link DefaultCountdownUpdateCount `DefaultCountdownUpdateCount`}\n     * to get a fixed interval which will make for {@link DefaultCountdownUpdateCount `DefaultCountdownUpdateCount`} countdown updates.\n     * \n     * ⚠️ Extending classes should:\n     * 1. Declare an `@Input()` setter named `{selector}CountdownInterval` (e.g. onObserverCompleteCountdownInterval) which will set this value.\n     * 2. Provide the above documentation for the setter property.\n     *\n     * @protected\n     * @type {DurationAnnotation}\n     */\n    protected countdownInterval?: DurationAnnotation | 'animationFrames';\n    \n    /**\n     * ### Why BehaviorSubject<... | null> and not Subject<...>\n     * `input` is set from @Input properties. For some reason, Angular passes-in the first value BEFORE\n     * ngOnInit, even though other @Input properties (e.g. showAfter, showFor) are passed AFTER ngOnInit.\n     * If subscription occurs in the constructor, `input` will emit the first observable too fast, which\n     * might lead to pipes breaking or misbehaving if they rely on properties to be instantiated first.\n     * \n     * This leads to subscribing in ngOnInit, to allow Angular time to initialize those.\n     * BUT, if `input` is a Subject, as the first value was already emitted BEFORE ngOnInit, it will not be\n     * captured by our subscription to `input`. Hence the BehaviorSubject - To allow capturing that first observable.\n     */\n    protected readonly input: BehaviorSubject<Observable<T> | null> = new BehaviorSubject(null as Observable<T> | null);\n\n    /**\n     * `true` if {@link OnObserverBaseDirective.viewMode viewMode} is `'single'`; otherwise, `false`.\n     *\n     * @readonly\n     * @type {boolean}\n     */\n    public get isSingleView(): boolean { return this.viewMode === 'single'  ; }\n    /**\n     * `true` if {@link OnObserverBaseDirective.viewMode viewMode} is `'multiple'`; otherwise, `false`.\n     *\n     * @readonly\n     * @type {boolean}\n     */\n    public get isMultiView (): boolean { return this.viewMode === 'multiple'; }\n\n    constructor(private readonly template: TemplateRef<OnObserverContext<T>>, private readonly viewContainer: ViewContainerRef)\n    {\n        super();\n    }\n    \n    ngOnInit()\n    {\n        // See `this.input` documentation for why subscription is done in ngOnInit.\n        this.subscribe(this.renderFeed());\n    }\n\n    /**\n     * Destroys any rendered view.\n     *\n     * @private\n     */\n    private destroyAll(): void\n    {\n        this.commitments.forEach(({ view }) => view?.destroy());\n    }\n\n    /**\n     * Creates the main feed the directive will subscribe to. The feed will listen to changed to {@link OnObserverBaseDirective.input `input`},\n     * then switch to the newly received observable in order to start observing it.\n     * The newly received observable will then be materialized and calls will be aggregated as commitment objects with information about\n     * what to render and when. Those commitments will pass through the {@link OnObserverBaseDirective.onCommitmentsChanged onCommitmentsChanged()} method\n     * which will update the global commitment and create observables with commitments to render and auto destroy views according to the\n     * given commitments.\n     * \n     * This feed is the single reactive entrypoint, meaning any observable created by the directive will be created inside of this\n     * observable or its nested observables. Any time a nested observable is created it will be switched to. This allows the pipeline to\n     * completely startover when a new call is made or a new {@link OnObserverBaseDirective.input `input`} observable is provided, thus keeping\n     * a consistent stream of data to the {@link OnObserverBaseDirective.commitments global commitments map}.\n     *\n     * @private\n     * @return {Observable<ViewRenderCommitment<T>[]>} An observable as described above.\n     */\n    private renderFeed(): Observable<ViewRenderCommitment<T>[]>\n    {\n        return this.input.pipe(\n            // Make sure views are reset if a new observable is passed-in to the directive\n            tap      (()          => this.destroyAll()),\n            // Free memory once the directive is destroyed and the subscription closed\n            // TODO: Will this actually execute? `this.subscribe()` doesn't complete the observable but unsubscribes on component destruction\n            finalize (()          => this.destroyAll()),\n            switchMap(input       => input ? this.observeInput(input) : EMPTY),\n            map      (call        => this.shouldRender(call) ? this.aggregateCommitments(call) : this.deaggregateCommitments()),\n            switchMap(commitments => this.onCommitmentsChanged(commitments)),\n        );\n    }\n\n    /**\n     * Materializes the observable and converts notifications to an {@link ObserverCall} object.\n     * The returned observable will always start with a `'resolving'` call.\n     *\n     * @private\n     * @param {Observable<T>} input The observable to watch.\n     * @return {Observable<ObserverCall<T>>} A materialized observable which describes each observable notification as an {@link ObserverCall} object.\n     */\n    private observeInput(input: Observable<T>): Observable<ObserverCall<T>>\n    {\n        return input.pipe(\n            materialize(),\n            map        (ObserverCall.fromNotification),\n            startWith  (ObserverCall.resolving<T>())\n        );\n    }\n\n    /**\n     * Checks whether the given observer call should be rendered according to the interception config in {@link OnObserverBaseDirective.renderOnCallsTo renderOnCallsTo}.\n     *\n     * @private\n     * @param {ObserverCall<T>} The call to check.\n     * @return {boolean} `true` if the call should be rendered; otherwise `false`.\n     */\n    private shouldRender({ name }: ObserverCall<T>): boolean\n    {\n        const observeOn = Array.isArray(this.renderOnCallsTo) ? this.renderOnCallsTo : [this.renderOnCallsTo];\n        \n        return observeOn.includes(name);\n    }\n    \n    /**\n     * Creates the new commitments map when a new commitment should render.\n     * \n     * When `viewMode` is `'single'` the map will always contain a single commitment. If the commitment hasn't been rendered yet, a new commitment will be created.\n     * Otherwise, the existing commitment will be replaced by a clone with updated parameters (i.e. delay and countdown).\n     * \n     * When `viewMode` is `'multiple'` a new commitment will always be added to the map.\n     *\n     * @private\n     * @param {ObserverCall<T>} call The new call which should render.\n     * @return {RenderCommitmentMap<T>} The new map of commitments to render.\n     */\n    private aggregateCommitments(call: ObserverCall<T>): RenderCommitmentMap<T>\n    {\n        const commitments = this.commitments;\n        // In single-view mode, if there's already a commitment, we'll replace it with a new one. Otherwise, we'll create a fresh one.\n        const newCommitment = this.isSingleView && this.mainCommitment\n            ? ViewRenderCommitment.update(this.mainCommitment, call)\n            : ViewRenderCommitment.create(call, durationToMs(this.showAfter), durationToMs(this.showFor || 0));\n\n        return new Map(commitments.set(newCommitment.commitmentId, newCommitment));\n    }\n\n    /**\n     * Creates the new commitments map when a new commitment shouldn't render.\n     *\n     * @private\n     * @return {RenderCommitmentMap<T>} If `showFor` is specified, meaning views should be auto destroyed after a certain duration,\n     * the current commitments will kept alive by returning them as a new map. This will allow recommiting to the same render parameters (i.e. delay and countdown).\n     * Otherwise, when views should destroy immediately, an empty map will be returned.\n     */\n    private deaggregateCommitments(): RenderCommitmentMap<T>\n    {\n        return this.showFor ? new Map(this.commitments) : new Map();\n    }\n    \n    /**\n     * Handles the changes to the current commitment of the watched observable and creates and commits to render all commitments.\n     * \n     * This will update the global commitment map. If an empty map is passed, all previous commitments will be destroyed.\n     *\n     * @private\n     * @param {RenderCommitmentMap<T>} commitments The current commitment map.\n     * @return {Observable<ViewRenderCommitment<T>[]>} An observable joining all render commitments.\n     */\n    private onCommitmentsChanged(commitments: RenderCommitmentMap<T>): Observable<ViewRenderCommitment<T>[]>\n    {\n        // If the commitment map has been reset, destroy any previously rendered view\n        if (!commitments.size) this.destroyAll();\n\n        // Update the global commitment map\n        this.commitments = commitments;\n        // Map all commitments to a commitment to render observable\n        const runCommitments = Array.from(commitments.keys())\n                                    .map((commitmentId, index) => this.commitToRender(commitments, commitmentId, index));\n            \n        return forkJoin(runCommitments);\n    }\n    \n    /**\n     * Creates an observable that initiates the render flow for an emission. Render flow is as follows:\n     * 1. Delay render until the time for render (i.e. {@link ViewRenderCommitment.renderAt}) has come.\n     * 2. Render the view.\n     * 3. Update the {@link OnObserverBaseDirective.commitments global commitments map} with the rendered commitment.\n     * 4. Initiate an auto destroy timer. See {@link OnObserverBaseDirective.autoDestroy autoDestroy()}.\n     * 5. Remove the destroyed commitment from the {@link OnObserverBaseDirective.commitments global commitments map}.\n     *\n     * @private\n     * @param {RenderCommitmentMap<T>} commitments The current commitment map holding all commitments to render.\n     * @param {string} commitmentId The id of the commitment to render.\n     * @param {number} index The index of the view to be rendered.\n     * @return {Observable<ViewRenderCommitment<T>>} An observable that initiates the render flow for an emission.\n     */\n    private commitToRender(commitments: RenderCommitmentMap<T>, commitmentId: string, index: number): Observable<ViewRenderCommitment<T>>\n    {\n        if (!commitments.has(commitmentId)) throw new Error(`\n            *${ this.selector } has encountered an inconsistency issue. Tried to commit to rendering commitment with ID ${ commitmentId }, but no commitment object exists with that ID.\n            Please consider filing an issue and providing a stack trace here: https://github.com/BeSpunky/angular-zen/issues/new?assignees=BeSpunky&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=%F0%9F%90%9B+\n        `);\n\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return of(commitments.get(commitmentId)!).pipe(\n            switchMap(commitment          => this.delayRender(commitment)),\n            // Actually perform rendering (or update the view if already rendered)\n            switchMap(commitment          => this.renderCommitment(commitment, index)),\n            // The commitment returned from `renderCommitment()` now contains the view, so update the global map\n            tap      (renderedCommitment  => commitments.set(commitmentId, renderedCommitment)),\n            // Initiate the auto-destroy mechanism (will skip if `showFor` wasn't specified)\n            switchMap(renderedCommitment  => this.autoDestroy(renderedCommitment)),\n            // Commitment has completed successfully. Remove it from the global map.\n            tap      (renderedCommitment  => renderedCommitment.autoDestroys ? commitments.delete(commitmentId) : void 0)\n        );\n    }\n\n    /**\n     * Creates an observable which delays the pipeline until the time to render the view (i.e. {@link ViewRenderCommitment.renderAt}) comes.\n     *\n     * @private\n     * @param {ViewRenderCommitment<T>} commitment The commitment to delay.\n     * @return {Observable<ViewRenderCommitment<T>>} An observable which delays the pipeline until the time to render the view (i.e. {@link ViewRenderCommitment.renderAt}) comes.\n     */\n    private delayRender(commitment: ViewRenderCommitment<T>): Observable<ViewRenderCommitment<T>>\n    {\n        return of(commitment).pipe(\n            delay(new Date(commitment.renderAt)),\n        );\n    }\n\n    /**\n     * Creates a new context for the given commitment and renders (or updates) the view.\n     *\n     * @private\n     * @param {ViewRenderCommitment<T>} commitment The commitment for which to create the context and render the view.\n     * @param {number} index The index of the view. If `viewMode` is `'single'` this should always be `0` as there is only one view.\n     * @return {Observable<ViewRenderCommitment<T>>} An observable which renderes the commitment, then emits a new updated commitment referencing the rendered view.\n     */\n    private renderCommitment(commitment: ViewRenderCommitment<T>, index: number): Observable<ViewRenderCommitment<T>>\n    {\n        const context            = OnObserverContext.fromCommitment<T>(this.selector, index, commitment);\n        const renderedCommitment = this.renderOrUpdateView(commitment, context);\n\n        return of(renderedCommitment);\n    }\n\n    /**\n     * Creates an interval observable which counts down until the time to destroy the view is reached, then destroys the view.\n     * While the timer is running, the rendered view's context will be updated in fixed intervals with the time left before destruction.\n     * \n     * @see {@link OnObserverBaseDirective.defineCountdownInterval defineCountdownInterval()} for more about the fixed countdown interval.\n     * \n     * If {@link OnObserverBaseDirective.countdownInterval `countdownInterval`} is `'animationFrames'`, the rxjs `animationFrames()` function\n     * will be used instead of the interval.\n     * \n     * @private\n     * @param {ViewRenderCommitment<T>} commitment The rendered commitment for which to initiate auto destroy.\n     * @return {Observable<ViewRenderCommitment<T>>} A timer observable which counts down until the time to destroy the view is reached, then destroys the view, while\n     * updating the context with the time left for destruction. The observable will emit the commitment \n     */\n    private autoDestroy(commitment: ViewRenderCommitment<T>): Observable<ViewRenderCommitment<T>>\n    {\n        const { destroyAt, view } = commitment;\n\n        if (!(destroyAt && view)) return of(commitment);\n\n        const countdownInterval = this.defineCountdownInterval();\n        const countdown: Observable<unknown> = countdownInterval === 'animationFrames' ? animationFrames() : interval(countdownInterval);\n\n        return countdown.pipe(\n            map      (()         => destroyAt - Date.now()),\n            map      (timeLeftMs => [timeLeftMs < 0 ? 0 : timeLeftMs, commitment.showFor - timeLeftMs]),\n            tap      (([timeLeftMs, elapsedTimeMs]) => this.updateViewContextCountdown(view, timeLeftMs, elapsedTimeMs)),\n            takeWhile(([timeLeftMs]) => timeLeftMs > 0, true),\n            filter   (([timeLeftMs]) => timeLeftMs <= 0),\n            tap      (() => view.destroy()),\n            mapTo    (commitment)\n        );\n    }\n\n    /**\n     * Makes sure the specified commitment is rendered and its context is updated, then returns an updated commitment with the rendered (or updated) view.\n     * If the view has been previously rendered, its context will be updated. Otherwise, the view will be rendered for the first time.\n     * \n     * The new commitment will be used further down the pipeline to update the internal `commitments` map.\n     * \n     * @see {@link OnObserverBaseDirective.commitToRender `commitToRender()`}.\n     *\n     * @private\n     * @param {ViewRenderCommitment<T>} commitment The commitment for which the view should be rendered.countdown\n     * @param {OnObserverContext<T>} context The context object to feed into the view.\n     * @return {ViewRenderCommitment<T>} The new commitment containing the rendered (or updated) view.\n     */\n    private renderOrUpdateView(commitment: ViewRenderCommitment<T>, context: OnObserverContext<T>): ViewRenderCommitment<T>\n    {\n        if (commitment.view)\n        {\n            commitment.view.context = context;\n            \n            return ViewRenderCommitment.rendered(commitment, commitment.view);\n        }\n        \n        return ViewRenderCommitment.rendered(commitment, this.viewContainer.createEmbeddedView(this.template, context));\n    }\n\n    /**\n     * Breaks down the time left before the view is destroyed to its parts and updates the view context so that the user may present\n     * a countdown or any other UI component indicating when the view will be destroyed.\n     *\n     * @private\n     * @param {RenderedView<T>} view The view in which to update the countdown.\n     * @param {number} timeLeftMs The time left (in milliseconds) for the view before being destroyed.\n     * @param {number} timeElapsedMs The time elapsed (in milliseconds) from the moment the view was rendered.\n     */\n    private updateViewContextCountdown(view: RenderedView<T>, timeLeftMs: number, timeElapsedMs: number): void\n    {    \n        const remaining = breakdownTime(timeLeftMs);\n        const elapsed   = breakdownTime(timeElapsedMs);\n\n        const { $implicit, call, index } = view.context;\n\n        // TODO: Remove the `showingFor` argument when launching v6.0.0\n        view.context = new OnObserverContext(this.selector, index, call, $implicit, remaining, remaining, elapsed);\n    }\n\n    /**\n     * Defines the interval (in milliseconds) with which countdown updates should be made to the view's context.\n     * If the user has defined a value through {@link OnObserverBaseDirective.countdownInterval `countdownInterval`}, that value will be used.\n     * If the user has defined `'animationFrames'` as the value for {@link OnObserverBaseDirective.countdownInterval `countdownInterval`}, this will return `'animationFrames'`.\n     * Otherwise, {@link OnObserverBaseDirective.showFor `showFor`} will be divided by a fixed number defined by {@link DefaultCountdownUpdateCount `DefaultCountdownUpdateCount`}, currently 30, meaning the user will get\n     * 30 countdown updates with fixed intervals between them before the view is destroyed.\n     *\n     * @private\n     * @return {number} The interval with which countdown updates should be made to the view's context.\n     */\n    private defineCountdownInterval(): number | 'animationFrames'\n    {\n        // If the view should persist, or it should auto-destroy but percision has been manually specified, do nothing\n        if (!this.showFor) throw new Error(`\n            Auto-destroy countdown seems to have been initiated when 'showFor' hasn't been set. This shouldn't have happend.\n            Please consider filing an issue and providing a stack trace here: https://github.com/BeSpunky/angular-zen/issues/new?assignees=BeSpunky&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=%F0%9F%90%9B+\n        `);\n        \n        if (this.countdownInterval === 'animationFrames') return 'animationFrames';\n\n        if (this.countdownInterval) return durationToMs(this.countdownInterval);\n\n        const showForMs = durationToMs(this.showFor);\n\n        return showForMs / DefaultCountdownUpdateCount;\n    }\n}\n"]}