theme-lib
Version:
This is a simple example Angular Library published to npm.
296 lines • 27.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { fromEvent as observableFromEvent, merge as observableMerge } from 'rxjs';
import { debounceTime, delay, filter, repeat, share, switchMap, takeUntil, takeWhile, map } from 'rxjs/operators';
/** @enum {string} */
const NbTrigger = {
CLICK: 'click',
HOVER: 'hover',
HINT: 'hint',
FOCUS: 'focus',
};
export { NbTrigger };
/*
* Provides entity with two event stream: show and hide.
* Each stream provides different events depends on implementation.
* We have three main trigger strategies: click, hint and hover.
* */
/*
* TODO maybe we have to use renderer.listen instead of observableFromEvent?
* Renderer provides capability use it in service worker, ssr and so on.
* */
/**
* @abstract
*/
export class NbTriggerStrategy {
/**
* @param {?} document
* @param {?} host
* @param {?} container
*/
constructor(document, host, container) {
this.document = document;
this.host = host;
this.container = container;
}
/**
* @protected
* @param {?} event
* @return {?}
*/
isNotOnHostOrContainer(event) {
return !this.isOnHost(event) && !this.isOnContainer(event);
}
/**
* @protected
* @param {?} event
* @return {?}
*/
isOnHostOrContainer(event) {
return this.isOnHost(event) || this.isOnContainer(event);
}
/**
* @protected
* @param {?} __0
* @return {?}
*/
isOnHost({ target }) {
return this.host.contains((/** @type {?} */ (target)));
}
/**
* @protected
* @param {?} __0
* @return {?}
*/
isOnContainer({ target }) {
return this.container() && this.container().location.nativeElement.contains(target);
}
}
if (false) {
/** @type {?} */
NbTriggerStrategy.prototype.show$;
/** @type {?} */
NbTriggerStrategy.prototype.hide$;
/**
* @type {?}
* @protected
*/
NbTriggerStrategy.prototype.document;
/**
* @type {?}
* @protected
*/
NbTriggerStrategy.prototype.host;
/**
* @type {?}
* @protected
*/
NbTriggerStrategy.prototype.container;
}
/*
* Creates show and hide event streams.
* Fires toggle event when the click was performed on the host element.
* Fires close event when the click was performed on the document but
* not on the host or container.
* */
export class NbClickTriggerStrategy extends NbTriggerStrategy {
constructor() {
super(...arguments);
// since we should track click for both SHOW and HIDE event we firstly need to track the click and the state
// of the container and then later on decide should we hide it or show
// if we track the click & state separately this will case a behavior when the container is getting shown
// and then hidden right away
this.click$ = observableFromEvent(this.document, 'click')
.pipe(map((event) => (/** @type {?} */ ([!this.container() && this.isOnHost(event), event]))), share());
this.show$ = this.click$
.pipe(filter(([shouldShow]) => shouldShow), map(([, event]) => event));
this.hide$ = this.click$
.pipe(filter(([shouldShow, event]) => !shouldShow && !this.isOnContainer(event)), map(([, event]) => event));
}
}
if (false) {
/**
* @type {?}
* @protected
*/
NbClickTriggerStrategy.prototype.click$;
/** @type {?} */
NbClickTriggerStrategy.prototype.show$;
/** @type {?} */
NbClickTriggerStrategy.prototype.hide$;
}
/*
* Creates show and hide event streams.
* Fires open event when a mouse hovers over the host element and stay over at least 100 milliseconds.
* Fires close event when the mouse leaves the host element and stops out of the host and popover container.
* */
export class NbHoverTriggerStrategy extends NbTriggerStrategy {
constructor() {
super(...arguments);
this.show$ = observableFromEvent(this.host, 'mouseenter')
.pipe(filter(() => !this.container()), delay(100), takeUntil(observableFromEvent(this.host, 'mouseleave')), repeat());
this.hide$ = observableFromEvent(this.host, 'mouseleave')
.pipe(switchMap(() => observableFromEvent(this.document, 'mousemove')
.pipe(debounceTime(100), takeWhile(() => !!this.container()), filter(event => this.isNotOnHostOrContainer(event)))));
}
}
if (false) {
/** @type {?} */
NbHoverTriggerStrategy.prototype.show$;
/** @type {?} */
NbHoverTriggerStrategy.prototype.hide$;
}
/*
* Creates show and hide event streams.
* Fires open event when a mouse hovers over the host element and stay over at least 100 milliseconds.
* Fires close event when the mouse leaves the host element.
* */
export class NbHintTriggerStrategy extends NbTriggerStrategy {
constructor() {
super(...arguments);
this.show$ = observableFromEvent(this.host, 'mouseenter')
.pipe(delay(100), takeUntil(observableFromEvent(this.host, 'mouseleave')),
// this `delay & takeUntil & repeat` operators combination is a synonym for `conditional debounce`
// meaning that if one event occurs in some time after the initial one we won't react to it
repeat());
this.hide$ = observableFromEvent(this.host, 'mouseleave');
}
}
if (false) {
/** @type {?} */
NbHintTriggerStrategy.prototype.show$;
/** @type {?} */
NbHintTriggerStrategy.prototype.hide$;
}
/*
* Creates show and hide event streams.
* Fires open event when a focus is on the host element and stay over at least 100 milliseconds.
* Fires close event when the focus leaves the host element.
* */
export class NbFocusTriggerStrategy extends NbTriggerStrategy {
constructor() {
super(...arguments);
this.focusOut$ = observableFromEvent(this.host, 'focusout')
.pipe(switchMap(() => observableFromEvent(this.document, 'focusin')
.pipe(takeWhile(() => !!this.container()), filter(event => this.isNotOnHostOrContainer(event)))));
this.clickIn$ = observableFromEvent(this.host, 'click')
.pipe(filter(() => !this.container()));
this.clickOut$ = observableFromEvent(this.document, 'click')
.pipe(filter(() => !!this.container()), filter(event => this.isNotOnHostOrContainer(event)));
this.tabKeyPress$ = observableFromEvent(this.document, 'keydown')
.pipe(filter((event) => event.keyCode === 9), filter(() => !!this.container()));
this.show$ = observableMerge(observableFromEvent(this.host, 'focusin'), this.clickIn$)
.pipe(filter(() => !this.container()), debounceTime(100), takeUntil(observableFromEvent(this.host, 'focusout')), repeat());
this.hide$ = observableMerge(this.focusOut$, this.tabKeyPress$, this.clickOut$);
}
}
if (false) {
/**
* @type {?}
* @protected
*/
NbFocusTriggerStrategy.prototype.focusOut$;
/**
* @type {?}
* @protected
*/
NbFocusTriggerStrategy.prototype.clickIn$;
/**
* @type {?}
* @protected
*/
NbFocusTriggerStrategy.prototype.clickOut$;
/**
* @type {?}
* @protected
*/
NbFocusTriggerStrategy.prototype.tabKeyPress$;
/** @type {?} */
NbFocusTriggerStrategy.prototype.show$;
/** @type {?} */
NbFocusTriggerStrategy.prototype.hide$;
}
export class NbTriggerStrategyBuilder {
/**
* @template THIS
* @this {THIS}
* @param {?} document
* @return {THIS}
*/
document(document) {
(/** @type {?} */ (this))._document = document;
return (/** @type {?} */ (this));
}
/**
* @template THIS
* @this {THIS}
* @param {?} trigger
* @return {THIS}
*/
trigger(trigger) {
(/** @type {?} */ (this))._trigger = trigger;
return (/** @type {?} */ (this));
}
/**
* @template THIS
* @this {THIS}
* @param {?} host
* @return {THIS}
*/
host(host) {
(/** @type {?} */ (this))._host = host;
return (/** @type {?} */ (this));
}
/**
* @template THIS
* @this {THIS}
* @param {?} container
* @return {THIS}
*/
container(container) {
(/** @type {?} */ (this))._container = container;
return (/** @type {?} */ (this));
}
/**
* @return {?}
*/
build() {
switch (this._trigger) {
case NbTrigger.CLICK:
return new NbClickTriggerStrategy(this._document, this._host, this._container);
case NbTrigger.HINT:
return new NbHintTriggerStrategy(this._document, this._host, this._container);
case NbTrigger.HOVER:
return new NbHoverTriggerStrategy(this._document, this._host, this._container);
case NbTrigger.FOCUS:
return new NbFocusTriggerStrategy(this._document, this._host, this._container);
default:
throw new Error('Trigger have to be provided');
}
}
}
if (false) {
/**
* @type {?}
* @protected
*/
NbTriggerStrategyBuilder.prototype._host;
/**
* @type {?}
* @protected
*/
NbTriggerStrategyBuilder.prototype._container;
/**
* @type {?}
* @protected
*/
NbTriggerStrategyBuilder.prototype._trigger;
/**
* @type {?}
* @protected
*/
NbTriggerStrategyBuilder.prototype._document;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay-trigger.js","sourceRoot":"ng://theme-lib/","sources":["lib/components/cdk/overlay/overlay-trigger.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from '@angular/core';\r\nimport { fromEvent as observableFromEvent, merge as observableMerge, Observable } from 'rxjs';\r\nimport { debounceTime, delay, filter, repeat, share, switchMap, takeUntil, takeWhile, map } from 'rxjs/operators';\r\n\r\n\r\nexport enum NbTrigger {\r\n  CLICK = 'click',\r\n  HOVER = 'hover',\r\n  HINT = 'hint',\r\n  FOCUS = 'focus',\r\n}\r\n\r\n/*\r\n * Provides entity with two event stream: show and hide.\r\n * Each stream provides different events depends on implementation.\r\n * We have three main trigger strategies: click, hint and hover.\r\n * */\r\n/*\r\n * TODO maybe we have to use renderer.listen instead of observableFromEvent?\r\n * Renderer provides capability use it in service worker, ssr and so on.\r\n * */\r\nexport abstract class NbTriggerStrategy {\r\n\r\n  protected isNotOnHostOrContainer(event: Event): boolean {\r\n    return !this.isOnHost(event) && !this.isOnContainer(event);\r\n  }\r\n\r\n  protected isOnHostOrContainer(event: Event): boolean {\r\n    return this.isOnHost(event) || this.isOnContainer(event);\r\n  }\r\n\r\n  protected isOnHost({ target }: Event): boolean {\r\n    return this.host.contains(target as Node);\r\n  }\r\n\r\n  protected isOnContainer({ target }: Event): boolean {\r\n    return this.container() && this.container().location.nativeElement.contains(target);\r\n  }\r\n\r\n  abstract show$: Observable<Event>;\r\n  abstract hide$: Observable<Event>;\r\n\r\n  constructor(protected document: Document, protected host: HTMLElement, protected container: () => ComponentRef<any>) {\r\n  }\r\n}\r\n\r\n/*\r\n * Creates show and hide event streams.\r\n * Fires toggle event when the click was performed on the host element.\r\n * Fires close event when the click was performed on the document but\r\n * not on the host or container.\r\n * */\r\nexport class NbClickTriggerStrategy extends NbTriggerStrategy {\r\n\r\n  // since we should track click for both SHOW and HIDE event we firstly need to track the click and the state\r\n  // of the container and then later on decide should we hide it or show\r\n  // if we track the click & state separately this will case a behavior when the container is getting shown\r\n  // and then hidden right away\r\n  protected click$: Observable<[boolean, Event]> = observableFromEvent<Event>(this.document, 'click')\r\n    .pipe(\r\n      map((event: Event) => [!this.container() && this.isOnHost(event), event] as [boolean, Event]),\r\n      share(),\r\n    );\r\n\r\n  readonly show$: Observable<Event> = this.click$\r\n    .pipe(\r\n      filter(([shouldShow]) => shouldShow),\r\n      map(([, event]) => event),\r\n    );\r\n\r\n  readonly hide$: Observable<Event> = this.click$\r\n    .pipe(\r\n      filter(([shouldShow, event]) => !shouldShow && !this.isOnContainer(event)),\r\n      map(([, event]) => event),\r\n    );\r\n}\r\n\r\n/*\r\n * Creates show and hide event streams.\r\n * Fires open event when a mouse hovers over the host element and stay over at least 100 milliseconds.\r\n * Fires close event when the mouse leaves the host element and stops out of the host and popover container.\r\n * */\r\nexport class NbHoverTriggerStrategy extends NbTriggerStrategy {\r\n\r\n  show$: Observable<Event> = observableFromEvent<Event>(this.host, 'mouseenter')\r\n    .pipe(\r\n      filter(() => !this.container()),\r\n      delay(100),\r\n      takeUntil(observableFromEvent(this.host, 'mouseleave')),\r\n      repeat(),\r\n    );\r\n\r\n  hide$: Observable<Event> = observableFromEvent<Event>(this.host, 'mouseleave')\r\n    .pipe(\r\n      switchMap(() => observableFromEvent<Event>(this.document, 'mousemove')\r\n        .pipe(\r\n          debounceTime(100),\r\n          takeWhile(() => !!this.container()),\r\n          filter(event => this.isNotOnHostOrContainer(event),\r\n          ),\r\n        ),\r\n      ),\r\n    );\r\n}\r\n\r\n/*\r\n * Creates show and hide event streams.\r\n * Fires open event when a mouse hovers over the host element and stay over at least 100 milliseconds.\r\n * Fires close event when the mouse leaves the host element.\r\n * */\r\nexport class NbHintTriggerStrategy extends NbTriggerStrategy {\r\n  show$: Observable<Event> = observableFromEvent<Event>(this.host, 'mouseenter')\r\n    .pipe(\r\n      delay(100),\r\n      takeUntil(observableFromEvent(this.host, 'mouseleave')),\r\n      // this `delay & takeUntil & repeat` operators combination is a synonym for `conditional debounce`\r\n      // meaning that if one event occurs in some time after the initial one we won't react to it\r\n      repeat(),\r\n    );\r\n\r\n  hide$: Observable<Event> = observableFromEvent(this.host, 'mouseleave');\r\n}\r\n\r\n\r\n/*\r\n * Creates show and hide event streams.\r\n * Fires open event when a focus is on the host element and stay over at least 100 milliseconds.\r\n * Fires close event when the focus leaves the host element.\r\n * */\r\nexport class NbFocusTriggerStrategy extends NbTriggerStrategy {\r\n\r\n  protected focusOut$: Observable<Event> = observableFromEvent<Event>(this.host, 'focusout')\r\n    .pipe(\r\n      switchMap(() => observableFromEvent<Event>(this.document, 'focusin')\r\n        .pipe(\r\n          takeWhile(() => !!this.container()),\r\n          filter(event => this.isNotOnHostOrContainer(event)),\r\n        ),\r\n      ),\r\n    );\r\n\r\n  protected clickIn$: Observable<Event> = observableFromEvent<Event>(this.host, 'click')\r\n    .pipe(\r\n      filter(() => !this.container()),\r\n    );\r\n\r\n  protected clickOut$: Observable<Event> = observableFromEvent<Event>(this.document, 'click')\r\n    .pipe(\r\n      filter(() => !!this.container()),\r\n      filter(event => this.isNotOnHostOrContainer(event)),\r\n    );\r\n\r\n  protected tabKeyPress$: Observable<Event> = observableFromEvent<Event>(this.document, 'keydown')\r\n    .pipe(\r\n      filter((event: KeyboardEvent) => event.keyCode === 9),\r\n      filter(() => !!this.container()),\r\n    );\r\n\r\n  show$: Observable<Event> = observableMerge(observableFromEvent<Event>(this.host, 'focusin'), this.clickIn$)\r\n    .pipe(\r\n      filter(() => !this.container()),\r\n      debounceTime(100),\r\n      takeUntil(observableFromEvent(this.host, 'focusout')),\r\n      repeat(),\r\n    );\r\n\r\n  hide$ = observableMerge(this.focusOut$, this.tabKeyPress$, this.clickOut$);\r\n}\r\n\r\nexport class NbTriggerStrategyBuilder {\r\n  protected _host: HTMLElement;\r\n  protected _container: () => ComponentRef<any>;\r\n  protected _trigger: NbTrigger;\r\n  protected _document: Document;\r\n\r\n  document(document: Document): this {\r\n    this._document = document;\r\n    return this;\r\n  }\r\n\r\n  trigger(trigger: NbTrigger): this {\r\n    this._trigger = trigger;\r\n    return this;\r\n  }\r\n\r\n  host(host: HTMLElement): this {\r\n    this._host = host;\r\n    return this;\r\n  }\r\n\r\n  container(container: () => ComponentRef<any>): this {\r\n    this._container = container;\r\n    return this;\r\n  }\r\n\r\n  build(): NbTriggerStrategy {\r\n    switch (this._trigger) {\r\n      case NbTrigger.CLICK:\r\n        return new NbClickTriggerStrategy(this._document, this._host, this._container);\r\n      case NbTrigger.HINT:\r\n        return new NbHintTriggerStrategy(this._document, this._host, this._container);\r\n      case NbTrigger.HOVER:\r\n        return new NbHoverTriggerStrategy(this._document, this._host, this._container);\r\n      case NbTrigger.FOCUS:\r\n        return new NbFocusTriggerStrategy(this._document, this._host, this._container);\r\n      default:\r\n        throw new Error('Trigger have to be provided');\r\n    }\r\n  }\r\n}\r\n"]}