@ethlete/core 1.10.0 → 1.10.1

package/esm2022/lib/components/structured-data/structured-data.component.mjs

@@ -0,0 +1,38 @@
+import { ChangeDetectionStrategy, Component, HostBinding, inject, Input, ViewEncapsulation } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+class StructuredDataComponent {
+    constructor() {
+        this._sanitizer = inject(DomSanitizer);
+    }
+    set data(currentValue) {
+        this.jsonLD = this.getSafeHTML(currentValue);
+    }
+    getSafeHTML(value) {
+        const json = value ? JSON.stringify(value, null, 2).replace(/<\/script>/g, '<\\/script>') : '';
+        const html = `<script type="application/ld+json">${json}</script>`;
+        return this._sanitizer.bypassSecurityTrustHtml(html);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: StructuredDataComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: StructuredDataComponent, isStandalone: true, selector: "et-structured-data", inputs: { data: "data" }, host: { properties: { "innerHTML": "this.jsonLD" }, styleAttribute: "display: none" }, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { StructuredDataComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: StructuredDataComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'et-structured-data',
+                    standalone: true,
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        style: 'display: none',
+                    },
+                }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], jsonLD: [{
+                type: HostBinding,
+                args: ['innerHTML']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/animatable/animatable.directive.mjs

@@ -0,0 +1,116 @@
+import { Directive, ElementRef, inject, InjectionToken, Input, isDevMode } from '@angular/core';
+import { BehaviorSubject, debounceTime, filter, fromEvent, map, merge, skip, Subject, takeUntil, tap, } from 'rxjs';
+import { DestroyService } from '../../services';
+import * as i0 from "@angular/core";
+export const ANIMATABLE_TOKEN = new InjectionToken('ANIMATABLE_DIRECTIVE_TOKEN');
+class AnimatableDirective {
+    constructor() {
+        this._didEmitStart = false;
+        this._parent = inject(ANIMATABLE_TOKEN, { optional: true, skipSelf: true });
+        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._elementRef = inject(ElementRef);
+        this._animationStart$ = new Subject();
+        this._animationEnd$ = new Subject();
+        this._animatedElement$ = new BehaviorSubject(this._elementRef.nativeElement);
+        this.animationStart$ = this._animationStart$.asObservable().pipe(debounceTime(0));
+        this.animationEnd$ = this._animationEnd$.asObservable().pipe(debounceTime(0));
+        this._hostActiveAnimationCount$ = new BehaviorSubject(0);
+        this._totalActiveAnimationCount$ = new BehaviorSubject(0);
+        this.isAnimating$ = this._totalActiveAnimationCount$.pipe(map((count) => count > 0), debounceTime(0));
+    }
+    set animatedElement(value) {
+        let newElement = null;
+        if (value === null || value === undefined) {
+            newElement = this._elementRef.nativeElement;
+        }
+        else if (typeof value === 'string') {
+            const el = document.querySelector(value);
+            if (el) {
+                newElement = el;
+            }
+            else {
+                if (isDevMode()) {
+                    console.warn(`Element with selector ${value} not found. Animatable directive will use host element.`);
+                }
+                newElement = this._elementRef.nativeElement;
+            }
+        }
+        else {
+            newElement = value;
+        }
+        if (this._animatedElement$.value !== newElement) {
+            this._animatedElement$.next(newElement);
+        }
+    }
+    ngOnInit() {
+        this._animatedElement$
+            .pipe(tap((el) => {
+            this._totalActiveAnimationCount$.next(this._totalActiveAnimationCount$.value - this._hostActiveAnimationCount$.value);
+            this._hostActiveAnimationCount$.next(0);
+            merge(fromEvent(el, 'animationstart'), fromEvent(el, 'transitionstart'))
+                .pipe(filter((e) => e.target === el), // skip events from children
+            tap(() => {
+                const count = this._hostActiveAnimationCount$.value + 1;
+                this._hostActiveAnimationCount$.next(count);
+                this._totalActiveAnimationCount$.next(count);
+            }), takeUntil(this._destroy$), takeUntil(this._animatedElement$.pipe(skip(1))))
+                .subscribe();
+            merge(fromEvent(el, 'animationend'), fromEvent(el, 'animationcancel'), fromEvent(el, 'transitionend'), fromEvent(el, 'transitioncancel'))
+                .pipe(filter((e) => e.target === el), // skip events from children
+            tap(() => {
+                const count = this._hostActiveAnimationCount$.value - 1;
+                this._hostActiveAnimationCount$.next(count);
+                this._totalActiveAnimationCount$.next(count);
+            }), takeUntil(this._destroy$), takeUntil(this._animatedElement$.pipe(skip(1))))
+                .subscribe();
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        this._totalActiveAnimationCount$
+            .pipe(tap((count) => {
+            if (count > 0 && !this._didEmitStart) {
+                this._animationStart$.next();
+                this._didEmitStart = true;
+            }
+            else if (count === 0) {
+                this._animationEnd$.next();
+                this._didEmitStart = false;
+            }
+        }), takeUntil(this._destroy$))
+            .subscribe();
+        if (this._parent) {
+            this._parent._hostActiveAnimationCount$
+                .pipe(takeUntil(this._destroy$), tap((count) => {
+                this._totalActiveAnimationCount$.next(count + this._hostActiveAnimationCount$.value);
+            }))
+                .subscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatableDirective, isStandalone: true, selector: "[etAnimatable]", inputs: { animatedElement: ["etAnimatable", "animatedElement"] }, providers: [
+            {
+                provide: ANIMATABLE_TOKEN,
+                useExisting: AnimatableDirective,
+            },
+            DestroyService,
+        ], exportAs: ["etAnimatable"], ngImport: i0 }); }
+}
+export { AnimatableDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etAnimatable]',
+                    exportAs: 'etAnimatable',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: ANIMATABLE_TOKEN,
+                            useExisting: AnimatableDirective,
+                        },
+                        DestroyService,
+                    ],
+                }]
+        }], propDecorators: { animatedElement: [{
+                type: Input,
+                args: ['etAnimatable']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animatable.directive.js","sourceRoot":"","sources":["../../../../../../../libs/core/src/lib/directives/animatable/animatable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, inject, InjectionToken, Input, isDevMode, OnInit } from '@angular/core';\nimport {\n  BehaviorSubject,\n  debounceTime,\n  filter,\n  fromEvent,\n  map,\n  merge,\n  Observable,\n  skip,\n  Subject,\n  takeUntil,\n  tap,\n} from 'rxjs';\nimport { DestroyService } from '../../services';\n\nexport const ANIMATABLE_TOKEN = new InjectionToken<AnimatableDirective>('ANIMATABLE_DIRECTIVE_TOKEN');\n\n@Directive({\n  selector: '[etAnimatable]',\n  exportAs: 'etAnimatable',\n  standalone: true,\n  providers: [\n    {\n      provide: ANIMATABLE_TOKEN,\n      useExisting: AnimatableDirective,\n    },\n    DestroyService,\n  ],\n})\nexport class AnimatableDirective implements OnInit {\n  private _didEmitStart = false;\n\n  private readonly _parent = inject(ANIMATABLE_TOKEN, { optional: true, skipSelf: true });\n  private readonly _destroy$ = inject(DestroyService, { host: true }).destroy$;\n  private readonly _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n\n  private readonly _animationStart$ = new Subject<void>();\n  private readonly _animationEnd$ = new Subject<void>();\n\n  @Input('etAnimatable')\n  set animatedElement(value: string | HTMLElement | null | undefined) {\n    let newElement: HTMLElement | null = null;\n    if (value === null || value === undefined) {\n      newElement = this._elementRef.nativeElement;\n    } else if (typeof value === 'string') {\n      const el = document.querySelector(value) as HTMLElement;\n\n      if (el) {\n        newElement = el;\n      } else {\n        if (isDevMode()) {\n          console.warn(`Element with selector ${value} not found. Animatable directive will use host element.`);\n        }\n\n        newElement = this._elementRef.nativeElement;\n      }\n    } else {\n      newElement = value;\n    }\n\n    if (this._animatedElement$.value !== newElement) {\n      this._animatedElement$.next(newElement);\n    }\n  }\n  private _animatedElement$ = new BehaviorSubject<HTMLElement>(this._elementRef.nativeElement);\n\n  readonly animationStart$ = this._animationStart$.asObservable().pipe(debounceTime(0));\n  readonly animationEnd$ = this._animationEnd$.asObservable().pipe(debounceTime(0));\n\n  private readonly _hostActiveAnimationCount$ = new BehaviorSubject<number>(0);\n  private readonly _totalActiveAnimationCount$ = new BehaviorSubject<number>(0);\n\n  readonly isAnimating$: Observable<boolean> = this._totalActiveAnimationCount$.pipe(\n    map((count) => count > 0),\n    debounceTime(0),\n  );\n\n  ngOnInit(): void {\n    this._animatedElement$\n      .pipe(\n        tap((el) => {\n          this._totalActiveAnimationCount$.next(\n            this._totalActiveAnimationCount$.value - this._hostActiveAnimationCount$.value,\n          );\n          this._hostActiveAnimationCount$.next(0);\n\n          merge(fromEvent<AnimationEvent>(el, 'animationstart'), fromEvent<TransitionEvent>(el, 'transitionstart'))\n            .pipe(\n              filter((e) => e.target === el), // skip events from children\n              tap(() => {\n                const count = this._hostActiveAnimationCount$.value + 1;\n                this._hostActiveAnimationCount$.next(count);\n                this._totalActiveAnimationCount$.next(count);\n              }),\n              takeUntil(this._destroy$),\n              takeUntil(this._animatedElement$.pipe(skip(1))),\n            )\n            .subscribe();\n\n          merge(\n            fromEvent<AnimationEvent>(el, 'animationend'),\n            fromEvent<AnimationEvent>(el, 'animationcancel'),\n            fromEvent<TransitionEvent>(el, 'transitionend'),\n            fromEvent<TransitionEvent>(el, 'transitioncancel'),\n          )\n            .pipe(\n              filter((e) => e.target === el), // skip events from children\n              tap(() => {\n                const count = this._hostActiveAnimationCount$.value - 1;\n                this._hostActiveAnimationCount$.next(count);\n                this._totalActiveAnimationCount$.next(count);\n              }),\n              takeUntil(this._destroy$),\n              takeUntil(this._animatedElement$.pipe(skip(1))),\n            )\n            .subscribe();\n        }),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n\n    this._totalActiveAnimationCount$\n      .pipe(\n        tap((count) => {\n          if (count > 0 && !this._didEmitStart) {\n            this._animationStart$.next();\n            this._didEmitStart = true;\n          } else if (count === 0) {\n            this._animationEnd$.next();\n            this._didEmitStart = false;\n          }\n        }),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n\n    if (this._parent) {\n      this._parent._hostActiveAnimationCount$\n        .pipe(\n          takeUntil(this._destroy$),\n          tap((count) => {\n            this._totalActiveAnimationCount$.next(count + this._hostActiveAnimationCount$.value);\n          }),\n        )\n        .subscribe();\n    }\n  }\n}\n"]}

package/esm2022/lib/directives/animated-lifecycle/animated-lifecycle.directive.mjs

@@ -0,0 +1,116 @@
+import { Directive, ElementRef, inject, InjectionToken, isDevMode } from '@angular/core';
+import { BehaviorSubject, map, switchMap, take, takeUntil, tap } from 'rxjs';
+import { DestroyService } from '../../services';
+import { createReactiveBindings, forceReflow, fromNextFrame } from '../../utils';
+import { AnimatableDirective, ANIMATABLE_TOKEN } from '../animatable';
+import * as i0 from "@angular/core";
+import * as i1 from "../animatable/animatable.directive";
+export const ANIMATED_LIFECYCLE_TOKEN = new InjectionToken('ANIMATED_LIFECYCLE_DIRECTIVE_TOKEN');
+const ANIMATION_CLASSES = {
+    enterFrom: 'et-animation-enter-from',
+    enterActive: 'et-animation-enter-active',
+    enterTo: 'et-animation-enter-to',
+    leaveFrom: 'et-animation-leave-from',
+    leaveActive: 'et-animation-leave-active',
+    leaveTo: 'et-animation-leave-to',
+};
+class AnimatedLifecycleDirective {
+    constructor() {
+        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._elementRef = inject(ElementRef);
+        this._animatable = inject(ANIMATABLE_TOKEN);
+        this._classList = this._elementRef.nativeElement.classList;
+        this._state$ = new BehaviorSubject('init');
+        this.state$ = this._state$.asObservable();
+        this._bindings = createReactiveBindings({
+            attribute: 'class.et-force-invisible',
+            observable: this._state$.pipe(map((state) => state === 'init')),
+        });
+    }
+    get state() {
+        return this._state$.value;
+    }
+    enter(config) {
+        if (this.state !== 'init' && this.state !== 'left' && isDevMode()) {
+            console.warn('Tried to enter but the element is not in the initial state. This may result in unexpected behavior.', this);
+        }
+        this._state$.next('entering');
+        if (!config?.onlyTransition) {
+            this._classList.add(ANIMATION_CLASSES.enterFrom);
+        }
+        forceReflow();
+        this._classList.add(ANIMATION_CLASSES.enterActive);
+        fromNextFrame()
+            .pipe(tap(() => {
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.enterFrom);
+                this._classList.add(ANIMATION_CLASSES.enterTo);
+            }
+        }), switchMap(() => this._animatable.animationEnd$), tap(() => {
+            this._state$.next('entered');
+            this._classList.remove(ANIMATION_CLASSES.enterActive);
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.enterTo);
+            }
+        }), takeUntil(this._destroy$), take(1))
+            .subscribe();
+    }
+    leave(config) {
+        if (this.state !== 'entered' && this.state !== 'entering' && isDevMode()) {
+            console.warn('Tried to leave while already leaving or left. This may result in unexpected behavior.', this);
+        }
+        if (this._classList.contains(ANIMATION_CLASSES.enterFrom) ||
+            this._classList.contains(ANIMATION_CLASSES.enterActive) ||
+            this._classList.contains(ANIMATION_CLASSES.enterTo)) {
+            this._classList.remove(ANIMATION_CLASSES.enterFrom);
+            this._classList.remove(ANIMATION_CLASSES.enterActive);
+            this._classList.remove(ANIMATION_CLASSES.enterTo);
+        }
+        this._state$.next('leaving');
+        if (!config?.onlyTransition) {
+            this._classList.add(ANIMATION_CLASSES.leaveFrom);
+        }
+        forceReflow();
+        this._classList.add(ANIMATION_CLASSES.leaveActive);
+        fromNextFrame()
+            .pipe(tap(() => {
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.leaveFrom);
+                this._classList.add(ANIMATION_CLASSES.leaveTo);
+            }
+        }), switchMap(() => this._animatable.animationEnd$), tap(() => {
+            this._state$.next('left');
+            this._classList.remove(ANIMATION_CLASSES.leaveActive);
+            if (!config?.onlyTransition) {
+                this._classList.remove(ANIMATION_CLASSES.leaveTo);
+            }
+        }), takeUntil(this._destroy$), take(1))
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedLifecycleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: AnimatedLifecycleDirective, isStandalone: true, selector: "[etAnimatedLifecycle]", providers: [
+            {
+                provide: ANIMATED_LIFECYCLE_TOKEN,
+                useExisting: AnimatedLifecycleDirective,
+            },
+            DestroyService,
+        ], exportAs: ["etAnimatedLifecycle"], hostDirectives: [{ directive: i1.AnimatableDirective }], ngImport: i0 }); }
+}
+export { AnimatedLifecycleDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AnimatedLifecycleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etAnimatedLifecycle]',
+                    exportAs: 'etAnimatedLifecycle',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: ANIMATED_LIFECYCLE_TOKEN,
+                            useExisting: AnimatedLifecycleDirective,
+                        },
+                        DestroyService,
+                    ],
+                    hostDirectives: [AnimatableDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animated-lifecycle.directive.js","sourceRoot":"","sources":["../../../../../../../libs/core/src/lib/directives/animated-lifecycle/animated-lifecycle.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, inject, InjectionToken, isDevMode } from '@angular/core';\nimport { BehaviorSubject, map, switchMap, take, takeUntil, tap } from 'rxjs';\nimport { DestroyService } from '../../services';\nimport { createReactiveBindings, forceReflow, fromNextFrame } from '../../utils';\nimport { AnimatableDirective, ANIMATABLE_TOKEN } from '../animatable';\n\nexport const ANIMATED_LIFECYCLE_TOKEN = new InjectionToken<AnimatedLifecycleDirective>(\n  'ANIMATED_LIFECYCLE_DIRECTIVE_TOKEN',\n);\n\nconst ANIMATION_CLASSES = {\n  enterFrom: 'et-animation-enter-from',\n  enterActive: 'et-animation-enter-active',\n  enterTo: 'et-animation-enter-to',\n  leaveFrom: 'et-animation-leave-from',\n  leaveActive: 'et-animation-leave-active',\n  leaveTo: 'et-animation-leave-to',\n} as const;\n\n@Directive({\n  selector: '[etAnimatedLifecycle]',\n  exportAs: 'etAnimatedLifecycle',\n  standalone: true,\n  providers: [\n    {\n      provide: ANIMATED_LIFECYCLE_TOKEN,\n      useExisting: AnimatedLifecycleDirective,\n    },\n    DestroyService,\n  ],\n  hostDirectives: [AnimatableDirective],\n})\nexport class AnimatedLifecycleDirective {\n  private readonly _destroy$ = inject(DestroyService, { host: true }).destroy$;\n  private readonly _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly _animatable = inject(ANIMATABLE_TOKEN);\n  private readonly _classList = this._elementRef.nativeElement.classList;\n\n  private _state$ = new BehaviorSubject<'entering' | 'entered' | 'leaving' | 'left' | 'init'>('init');\n  readonly state$ = this._state$.asObservable();\n\n  get state() {\n    return this._state$.value;\n  }\n\n  private readonly _bindings = createReactiveBindings({\n    attribute: 'class.et-force-invisible',\n    observable: this._state$.pipe(map((state) => state === 'init')),\n  });\n\n  enter(config?: { onlyTransition?: boolean }) {\n    if (this.state !== 'init' && this.state !== 'left' && isDevMode()) {\n      console.warn(\n        'Tried to enter but the element is not in the initial state. This may result in unexpected behavior.',\n        this,\n      );\n    }\n\n    this._state$.next('entering');\n\n    if (!config?.onlyTransition) {\n      this._classList.add(ANIMATION_CLASSES.enterFrom);\n    }\n\n    forceReflow();\n    this._classList.add(ANIMATION_CLASSES.enterActive);\n\n    fromNextFrame()\n      .pipe(\n        tap(() => {\n          if (!config?.onlyTransition) {\n            this._classList.remove(ANIMATION_CLASSES.enterFrom);\n            this._classList.add(ANIMATION_CLASSES.enterTo);\n          }\n        }),\n        switchMap(() => this._animatable.animationEnd$),\n        tap(() => {\n          this._state$.next('entered');\n          this._classList.remove(ANIMATION_CLASSES.enterActive);\n\n          if (!config?.onlyTransition) {\n            this._classList.remove(ANIMATION_CLASSES.enterTo);\n          }\n        }),\n        takeUntil(this._destroy$),\n        take(1),\n      )\n      .subscribe();\n  }\n\n  leave(config?: { onlyTransition?: boolean }) {\n    if (this.state !== 'entered' && this.state !== 'entering' && isDevMode()) {\n      console.warn('Tried to leave while already leaving or left. This may result in unexpected behavior.', this);\n    }\n\n    if (\n      this._classList.contains(ANIMATION_CLASSES.enterFrom) ||\n      this._classList.contains(ANIMATION_CLASSES.enterActive) ||\n      this._classList.contains(ANIMATION_CLASSES.enterTo)\n    ) {\n      this._classList.remove(ANIMATION_CLASSES.enterFrom);\n      this._classList.remove(ANIMATION_CLASSES.enterActive);\n      this._classList.remove(ANIMATION_CLASSES.enterTo);\n    }\n\n    this._state$.next('leaving');\n\n    if (!config?.onlyTransition) {\n      this._classList.add(ANIMATION_CLASSES.leaveFrom);\n    }\n\n    forceReflow();\n    this._classList.add(ANIMATION_CLASSES.leaveActive);\n\n    fromNextFrame()\n      .pipe(\n        tap(() => {\n          if (!config?.onlyTransition) {\n            this._classList.remove(ANIMATION_CLASSES.leaveFrom);\n            this._classList.add(ANIMATION_CLASSES.leaveTo);\n          }\n        }),\n        switchMap(() => this._animatable.animationEnd$),\n        tap(() => {\n          this._state$.next('left');\n          this._classList.remove(ANIMATION_CLASSES.leaveActive);\n\n          if (!config?.onlyTransition) {\n            this._classList.remove(ANIMATION_CLASSES.leaveTo);\n          }\n        }),\n        takeUntil(this._destroy$),\n        take(1),\n      )\n      .subscribe();\n  }\n}\n"]}

package/esm2022/lib/directives/click-outside/click-outside.directive.mjs

@@ -0,0 +1,38 @@
+import { Directive, ElementRef, EventEmitter, inject, Output } from '@angular/core';
+import { ClickObserverService } from '../../services';
+import * as i0 from "@angular/core";
+class ClickOutsideDirective {
+    constructor() {
+        this._elementRef = inject(ElementRef);
+        this._clickObserverService = inject(ClickObserverService);
+        this._subscription = null;
+        this.etClickOutside = new EventEmitter();
+    }
+    ngOnInit() {
+        setTimeout(() => {
+            this._subscription = this._clickObserverService.observe(this._elementRef.nativeElement).subscribe((event) => {
+                const activeElement = event.target;
+                const isInside = this._elementRef.nativeElement.contains(activeElement);
+                if (!isInside) {
+                    this.etClickOutside.emit(event);
+                }
+            });
+        });
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickOutsideDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: ClickOutsideDirective, isStandalone: true, selector: "[etClickOutside]", outputs: { etClickOutside: "etClickOutside" }, ngImport: i0 }); }
+}
+export { ClickOutsideDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ClickOutsideDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etClickOutside]',
+                    standalone: true,
+                }]
+        }], propDecorators: { etClickOutside: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/cursor-drag-scroll/cursor-drag-scroll.directive.mjs

@@ -0,0 +1,148 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, ElementRef, inject, Input } from '@angular/core';
+import { combineLatest, debounceTime, fromEvent, startWith, Subject, take, takeUntil, tap } from 'rxjs';
+import { ContentObserverService, DestroyService, ResizeObserverService } from '../../services';
+import { elementCanScroll } from '../../utils';
+import { CURSOR_DRAG_SCROLLING_CLASS, CURSOR_DRAG_SCROLLING_PREPARED_CLASS } from './cursor-drag-scroll.constants';
+import * as i0 from "@angular/core";
+class CursorDragScrollDirective {
+    constructor() {
+        this._subscriptions = [];
+        this._destroy$ = inject(DestroyService, { host: true }).destroy$;
+        this._elementRef = inject(ElementRef);
+        this._contentObserverService = inject(ContentObserverService);
+        this._resizeObserverService = inject(ResizeObserverService);
+        this._bufferUntilScroll = 5;
+        this._mouseUp$ = new Subject();
+        this._isScrolling = false;
+        this._canScroll = false;
+        this._currentScrollState = {
+            top: 0,
+            left: 0,
+            x: 0,
+            y: 0,
+        };
+        this._enabled = false;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = coerceBooleanProperty(value);
+        if (this._enabled) {
+            this._enableCursorDragScroll();
+        }
+        else {
+            this._disableCursorDragScroll();
+        }
+    }
+    ngAfterViewInit() {
+        if (this.enabled) {
+            this._enableCursorDragScroll();
+        }
+        else {
+            this._disableCursorDragScroll();
+        }
+    }
+    _enableCursorDragScroll() {
+        const contentResizeSub = combineLatest([
+            this._contentObserverService.observe(this._elementRef.nativeElement).pipe(startWith(null)),
+            this._resizeObserverService.observe(this._elementRef.nativeElement).pipe(startWith(null)),
+        ])
+            .pipe(debounceTime(25), tap(() => this._updateCanScrollState()), takeUntil(this._destroy$))
+            .subscribe();
+        const mousedownSub = fromEvent(this._elementRef.nativeElement, 'mousedown')
+            .pipe(tap((e) => this._onMouseDown(e)), takeUntil(this._destroy$))
+            .subscribe();
+        this._subscriptions.push(contentResizeSub, mousedownSub);
+        this._updateCanScrollState();
+    }
+    _disableCursorDragScroll() {
+        this._subscriptions.forEach((sub) => sub.unsubscribe());
+        this._subscriptions.length = 0;
+        this._elementRef.nativeElement.style.cursor = 'default';
+    }
+    _onMouseDown(e) {
+        if (!this._elementRef?.nativeElement || !this._canScroll) {
+            return;
+        }
+        const element = this._elementRef.nativeElement;
+        element.classList.add(CURSOR_DRAG_SCROLLING_PREPARED_CLASS);
+        this._elementRef.nativeElement.style.scrollSnapType = 'none';
+        this._elementRef.nativeElement.style.scrollBehavior = 'unset';
+        this._currentScrollState = {
+            left: this._elementRef.nativeElement.scrollLeft,
+            top: this._elementRef.nativeElement.scrollTop,
+            x: e.clientX,
+            y: e.clientY,
+        };
+        fromEvent(document, 'mousemove')
+            .pipe(tap((e) => this._mouseMoveHandler(e)), takeUntil(this._mouseUp$), takeUntil(this._destroy$))
+            .subscribe();
+        fromEvent(document, 'mouseup')
+            .pipe(tap(() => this._mouseUpHandler()), take(1), takeUntil(this._destroy$))
+            .subscribe();
+    }
+    _mouseMoveHandler(e) {
+        e.preventDefault();
+        if (!this._elementRef?.nativeElement) {
+            return;
+        }
+        const dx = e.clientX - this._currentScrollState.x;
+        const dy = e.clientY - this._currentScrollState.y;
+        if (Math.abs(dx) > this._bufferUntilScroll || Math.abs(dy) > this._bufferUntilScroll) {
+            const element = this._elementRef.nativeElement;
+            if (!this._isScrolling) {
+                this._isScrolling = true;
+                element.style.cursor = 'grabbing';
+                element.classList.add(CURSOR_DRAG_SCROLLING_CLASS);
+                element.scroll({
+                    top: this._currentScrollState.top - dy,
+                    left: this._currentScrollState.left - dx,
+                    behavior: 'smooth',
+                });
+            }
+            else {
+                element.scrollTop = this._currentScrollState.top - dy;
+                element.scrollLeft = this._currentScrollState.left - dx;
+            }
+        }
+    }
+    _mouseUpHandler() {
+        this._mouseUp$.next(true);
+        this._isScrolling = false;
+        if (!this._elementRef?.nativeElement) {
+            return;
+        }
+        this._elementRef.nativeElement.style.scrollSnapType = '';
+        this._elementRef.nativeElement.style.scrollBehavior = '';
+        this._elementRef.nativeElement.style.cursor = 'grab';
+        this._elementRef.nativeElement.classList.remove(CURSOR_DRAG_SCROLLING_CLASS);
+        this._elementRef.nativeElement.classList.remove(CURSOR_DRAG_SCROLLING_PREPARED_CLASS);
+    }
+    _updateCanScrollState() {
+        this._canScroll = elementCanScroll(this._elementRef.nativeElement);
+        if (this._canScroll) {
+            this._elementRef.nativeElement.style.cursor = 'grab';
+        }
+        else {
+            this._elementRef.nativeElement.style.cursor = 'default';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CursorDragScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: CursorDragScrollDirective, isStandalone: true, selector: "[etCursorDragScroll]", inputs: { enabled: ["etCursorDragScroll", "enabled"] }, providers: [DestroyService], exportAs: ["etCursorDragScroll"], ngImport: i0 }); }
+}
+export { CursorDragScrollDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CursorDragScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etCursorDragScroll]',
+                    exportAs: 'etCursorDragScroll',
+                    standalone: true,
+                    providers: [DestroyService],
+                }]
+        }], propDecorators: { enabled: [{
+                type: Input,
+                args: ['etCursorDragScroll']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cursor-drag-scroll.directive.js","sourceRoot":"","sources":["../../../../../../../libs/core/src/lib/directives/cursor-drag-scroll/cursor-drag-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { AfterViewInit, Directive, ElementRef, inject, Input } from '@angular/core';\nimport { combineLatest, debounceTime, fromEvent, startWith, Subject, Subscription, take, takeUntil, tap } from 'rxjs';\nimport { ContentObserverService, DestroyService, ResizeObserverService } from '../../services';\nimport { elementCanScroll } from '../../utils';\nimport { CURSOR_DRAG_SCROLLING_CLASS, CURSOR_DRAG_SCROLLING_PREPARED_CLASS } from './cursor-drag-scroll.constants';\n\n@Directive({\n  selector: '[etCursorDragScroll]',\n  exportAs: 'etCursorDragScroll',\n  standalone: true,\n  providers: [DestroyService],\n})\nexport class CursorDragScrollDirective implements AfterViewInit {\n  private readonly _subscriptions: Subscription[] = [];\n  private readonly _destroy$ = inject(DestroyService, { host: true }).destroy$;\n  private readonly _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private readonly _contentObserverService = inject(ContentObserverService);\n  private readonly _resizeObserverService = inject(ResizeObserverService);\n\n  private readonly _bufferUntilScroll = 5;\n  private readonly _mouseUp$ = new Subject<boolean>();\n\n  private _isScrolling = false;\n  private _canScroll = false;\n\n  private _currentScrollState = {\n    top: 0,\n    left: 0,\n    x: 0,\n    y: 0,\n  };\n\n  @Input('etCursorDragScroll')\n  get enabled(): boolean {\n    return this._enabled;\n  }\n  set enabled(value: BooleanInput) {\n    this._enabled = coerceBooleanProperty(value);\n\n    if (this._enabled) {\n      this._enableCursorDragScroll();\n    } else {\n      this._disableCursorDragScroll();\n    }\n  }\n  private _enabled = false;\n\n  ngAfterViewInit(): void {\n    if (this.enabled) {\n      this._enableCursorDragScroll();\n    } else {\n      this._disableCursorDragScroll();\n    }\n  }\n\n  private _enableCursorDragScroll() {\n    const contentResizeSub = combineLatest([\n      this._contentObserverService.observe(this._elementRef.nativeElement).pipe(startWith(null)),\n      this._resizeObserverService.observe(this._elementRef.nativeElement).pipe(startWith(null)),\n    ])\n      .pipe(\n        debounceTime(25),\n        tap(() => this._updateCanScrollState()),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n\n    const mousedownSub = fromEvent<MouseEvent>(this._elementRef.nativeElement, 'mousedown')\n      .pipe(\n        tap((e) => this._onMouseDown(e)),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n\n    this._subscriptions.push(contentResizeSub, mousedownSub);\n\n    this._updateCanScrollState();\n  }\n\n  private _disableCursorDragScroll() {\n    this._subscriptions.forEach((sub) => sub.unsubscribe());\n    this._subscriptions.length = 0;\n    this._elementRef.nativeElement.style.cursor = 'default';\n  }\n\n  private _onMouseDown(e: MouseEvent) {\n    if (!this._elementRef?.nativeElement || !this._canScroll) {\n      return;\n    }\n\n    const element = this._elementRef.nativeElement;\n\n    element.classList.add(CURSOR_DRAG_SCROLLING_PREPARED_CLASS);\n\n    this._elementRef.nativeElement.style.scrollSnapType = 'none';\n    this._elementRef.nativeElement.style.scrollBehavior = 'unset';\n\n    this._currentScrollState = {\n      left: this._elementRef.nativeElement.scrollLeft,\n      top: this._elementRef.nativeElement.scrollTop,\n      x: e.clientX,\n      y: e.clientY,\n    };\n\n    fromEvent<MouseEvent>(document, 'mousemove')\n      .pipe(\n        tap((e) => this._mouseMoveHandler(e)),\n        takeUntil(this._mouseUp$),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n\n    fromEvent<MouseEvent>(document, 'mouseup')\n      .pipe(\n        tap(() => this._mouseUpHandler()),\n        take(1),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n  }\n\n  private _mouseMoveHandler(e: MouseEvent) {\n    e.preventDefault();\n\n    if (!this._elementRef?.nativeElement) {\n      return;\n    }\n\n    const dx = e.clientX - this._currentScrollState.x;\n    const dy = e.clientY - this._currentScrollState.y;\n\n    if (Math.abs(dx) > this._bufferUntilScroll || Math.abs(dy) > this._bufferUntilScroll) {\n      const element = this._elementRef.nativeElement;\n\n      if (!this._isScrolling) {\n        this._isScrolling = true;\n\n        element.style.cursor = 'grabbing';\n        element.classList.add(CURSOR_DRAG_SCROLLING_CLASS);\n        element.scroll({\n          top: this._currentScrollState.top - dy,\n          left: this._currentScrollState.left - dx,\n          behavior: 'smooth',\n        });\n      } else {\n        element.scrollTop = this._currentScrollState.top - dy;\n        element.scrollLeft = this._currentScrollState.left - dx;\n      }\n    }\n  }\n\n  private _mouseUpHandler() {\n    this._mouseUp$.next(true);\n    this._isScrolling = false;\n\n    if (!this._elementRef?.nativeElement) {\n      return;\n    }\n\n    this._elementRef.nativeElement.style.scrollSnapType = '';\n    this._elementRef.nativeElement.style.scrollBehavior = '';\n\n    this._elementRef.nativeElement.style.cursor = 'grab';\n    this._elementRef.nativeElement.classList.remove(CURSOR_DRAG_SCROLLING_CLASS);\n    this._elementRef.nativeElement.classList.remove(CURSOR_DRAG_SCROLLING_PREPARED_CLASS);\n  }\n\n  private _updateCanScrollState() {\n    this._canScroll = elementCanScroll(this._elementRef.nativeElement);\n\n    if (this._canScroll) {\n      this._elementRef.nativeElement.style.cursor = 'grab';\n    } else {\n      this._elementRef.nativeElement.style.cursor = 'default';\n    }\n  }\n}\n"]}

package/esm2022/lib/directives/delayable/delayable.directive.mjs

@@ -0,0 +1,56 @@
+import { Directive, InjectionToken } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export const DELAYABLE_TOKEN = new InjectionToken('DELAYABLE_DIRECTIVE_TOKEN');
+class DelayableDirective {
+    constructor() {
+        this._isDelayed$ = new BehaviorSubject(false);
+    }
+    get isDelayed$() {
+        return this._isDelayed$.asObservable();
+    }
+    get isDelayed() {
+        return this._isDelayed$.value;
+    }
+    enableDelayed() {
+        if (this._isDelayed$.value) {
+            return;
+        }
+        this._isDelayed$.next(true);
+    }
+    disableDelayed() {
+        if (!this._isDelayed$.value) {
+            return;
+        }
+        this._isDelayed$.next(false);
+    }
+    setDelayed(val) {
+        if (this._isDelayed$.value === val) {
+            return;
+        }
+        this._isDelayed$.next(val);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DelayableDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: DelayableDirective, isStandalone: true, selector: "[etDelayable]", providers: [
+            {
+                provide: DELAYABLE_TOKEN,
+                useExisting: DelayableDirective,
+            },
+        ], exportAs: ["etDelayable"], ngImport: i0 }); }
+}
+export { DelayableDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DelayableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[etDelayable]',
+                    exportAs: 'etDelayable',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: DELAYABLE_TOKEN,
+                            useExisting: DelayableDirective,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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