cmat 0.0.3

package/esm2022/directives/animate-on-scroll/animate-on-scroll.directive.mjs

@@ -0,0 +1,126 @@
+import { Directive, Input } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { ScrollService } from './scroll.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./scroll.service";
+export class CmatAnimationOnScrollDirective {
+    constructor(elementRef, renderer, scroll) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.scroll = scroll;
+        // Pixel offset from screen bottom to the animated element to determine the start of the animation
+        this.offset = 80; // for scroll Listener
+        this._scrollSub = new Subscription();
+        this._resizeSub = new Subscription();
+    }
+    get id() {
+        return this.elementRef.nativeElement.id;
+    }
+    ngOnInit() {
+        if (!this.animationName) {
+            return;
+        }
+        // default visibility to false
+        this._isVisible = false;
+        this.useScroll = this.useScroll
+            ? this.useScroll
+            : this.useScroll === false
+                ? false
+                : true;
+        this.threshold = this.threshold ? this.threshold || 0.5 : 0.5;
+        // using intersecting observer by default, else fallback to scroll Listener
+        if ('IntersectionObserver' in window && this.useScroll) {
+            const options = {
+                root: null,
+                threshold: this.threshold,
+                rootMargin: '0px',
+            };
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => {
+                    if (!entry.isIntersecting) {
+                        return;
+                    }
+                    this.addAnimationClass();
+                });
+            }, options);
+            observer.observe(this.elementRef.nativeElement);
+            return;
+        }
+        // subscribe to scroll event using service
+        this._scrollSub = this.scroll.scrollObs.subscribe(() => this.manageVisibility());
+        // subscribe to resize event using service so scrolling position is always accurate
+        this._resizeSub = this.scroll.resizeObs.subscribe(() => this.manageVisibility());
+    }
+    ngAfterViewInit() {
+        // run visibility check initially in case the element is already visible in viewport
+        setTimeout(() => this.manageVisibility(), 1);
+    }
+    ngOnDestroy() {
+        this._scrollSub.unsubscribe();
+        this._resizeSub.unsubscribe();
+    }
+    manageVisibility() {
+        if (this._isVisible) {
+            // Optimisation; nothing to do if class has already been applied
+            return;
+        }
+        // check for window height, may change with a window resize
+        this.getWinHeight();
+        // get vertical position for selected element
+        this.getOffsetTop();
+        // we should trigger the addition of the animation class a little after getting to the element
+        const scrollTrigger = this._offsetTop + this.offset - this._winHeight;
+        // using values updated in service
+        if (this.scroll.pos >= scrollTrigger) {
+            this.addAnimationClass();
+        }
+    }
+    addAnimationClass() {
+        // stops execution if no class is provided
+        if (!this.animationName) {
+            return;
+        }
+        // mark this element visible, we won't remove the class after this
+        this._isVisible = true;
+        // use default for animate.css if no value provided
+        this.setClass(this.animationName);
+    }
+    setClass(classes) {
+        for (const c of classes.split(' ')) {
+            this.renderer.addClass(this.elementRef.nativeElement, c);
+        }
+    }
+    getWinHeight() {
+        this._winHeight = typeof window !== 'undefined' ? window.innerHeight : 0;
+    }
+    getOffsetTop() {
+        if (typeof this.elementRef.nativeElement.getBoundingClientRect === 'function') {
+            const viewportTop = this.elementRef.nativeElement.getBoundingClientRect().top;
+            const clientTop = this.elementRef.nativeElement.clientTop;
+            // get vertical position for selected element
+            this._offsetTop = viewportTop + this.scroll.pos - clientTop;
+        }
+        else {
+            this._offsetTop = 0;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatAnimationOnScrollDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ScrollService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatAnimationOnScrollDirective, isStandalone: true, selector: "[cmatAnimateOnScroll]", inputs: { animationName: "animationName", offset: "offset", useScroll: "useScroll", threshold: "threshold" }, providers: [ScrollService], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatAnimationOnScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cmatAnimateOnScroll]',
+                    providers: [ScrollService],
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ScrollService }], propDecorators: { animationName: [{
+                type: Input
+            }], offset: [{
+                type: Input
+            }], useScroll: [{
+                type: Input
+            }], threshold: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animate-on-scroll.directive.js","sourceRoot":"","sources":["../../../../../projects/cmat/directives/animate-on-scroll/animate-on-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, ElementRef, Input, OnDestroy, OnInit, Renderer2 } from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { ScrollService } from './scroll.service';\r\n\r\n@Directive({\r\n    selector: '[cmatAnimateOnScroll]',\r\n    providers:[ScrollService],\r\n    standalone: true\r\n})\r\nexport class CmatAnimationOnScrollDirective implements OnInit, OnDestroy, AfterViewInit {\r\n    @Input() animationName: string | null; // use fadeIn as default if not specified, specify null for no animation\r\n    // Pixel offset from screen bottom to the animated element to determine the start of the animation\r\n    @Input() offset: number = 80; // for scroll Listener\r\n    @Input() useScroll?: boolean;\r\n    @Input() threshold?: number; // for intersection observer only for the time being\r\n\r\n    private _offsetTop: number;\r\n    private _isVisible: boolean;\r\n    private _winHeight: number;\r\n    private _scrollSub: Subscription = new Subscription();\r\n    private _resizeSub: Subscription = new Subscription();\r\n\r\n    constructor(\r\n        private elementRef: ElementRef,\r\n        private renderer: Renderer2,\r\n        private scroll: ScrollService\r\n    ) { }\r\n\r\n    private get id(): string {\r\n        return this.elementRef.nativeElement.id;\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        if (!this.animationName) {\r\n            return;\r\n        }\r\n        // default visibility to false\r\n        this._isVisible = false;\r\n        this.useScroll = this.useScroll\r\n            ? this.useScroll\r\n            : this.useScroll === false\r\n                ? false\r\n                : true;\r\n        this.threshold = this.threshold ? this.threshold || 0.5 : 0.5;\r\n        // using intersecting observer by default, else fallback to scroll Listener\r\n        if ('IntersectionObserver' in window && this.useScroll) {\r\n            const options: IntersectionObserverInit = {\r\n                root: null,\r\n                threshold: this.threshold,\r\n                rootMargin: '0px',\r\n            };\r\n            const observer: IntersectionObserver = new IntersectionObserver(\r\n                (entries) => {\r\n                    entries.forEach((entry) => {\r\n                        if (!entry.isIntersecting) {\r\n                            return;\r\n                        }\r\n                        this.addAnimationClass();\r\n                    });\r\n                },\r\n                options\r\n            );\r\n            observer.observe(this.elementRef.nativeElement);\r\n            return;\r\n        }\r\n\r\n        // subscribe to scroll event using service\r\n        this._scrollSub = this.scroll.scrollObs.subscribe(() =>\r\n            this.manageVisibility()\r\n        );\r\n\r\n        // subscribe to resize event using service so scrolling position is always accurate\r\n        this._resizeSub = this.scroll.resizeObs.subscribe(() =>\r\n            this.manageVisibility()\r\n        );\r\n    }\r\n\r\n    ngAfterViewInit(): void {\r\n        // run visibility check initially in case the element is already visible in viewport\r\n        setTimeout(() => this.manageVisibility(), 1);\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._scrollSub.unsubscribe();\r\n        this._resizeSub.unsubscribe();\r\n    }\r\n\r\n    private manageVisibility(): void {\r\n        if (this._isVisible) {\r\n            // Optimisation; nothing to do if class has already been applied\r\n            return;\r\n        }\r\n\r\n        // check for window height, may change with a window resize\r\n        this.getWinHeight();\r\n\r\n        // get vertical position for selected element\r\n        this.getOffsetTop();\r\n\r\n        // we should trigger the addition of the animation class a little after getting to the element\r\n        const scrollTrigger = this._offsetTop + this.offset - this._winHeight;\r\n\r\n        // using values updated in service\r\n        if (this.scroll.pos >= scrollTrigger) {\r\n            this.addAnimationClass();\r\n        }\r\n    }\r\n\r\n    private addAnimationClass(): void {\r\n        // stops execution if no class is provided\r\n        if (!this.animationName) {\r\n            return;\r\n        }\r\n\r\n        // mark this element visible, we won't remove the class after this\r\n        this._isVisible = true;\r\n\r\n        // use default for animate.css if no value provided\r\n        this.setClass(this.animationName);\r\n    }\r\n\r\n    private setClass(classes: string): void {\r\n        for (const c of classes.split(' ')) {\r\n            this.renderer.addClass(this.elementRef.nativeElement, c);\r\n        }\r\n    }\r\n\r\n    private getWinHeight(): void {\r\n        this._winHeight = typeof window !== 'undefined' ? window.innerHeight : 0;\r\n    }\r\n\r\n    private getOffsetTop(): void {\r\n        if (\r\n            typeof this.elementRef.nativeElement.getBoundingClientRect === 'function'\r\n        ) {\r\n            const viewportTop =\r\n                this.elementRef.nativeElement.getBoundingClientRect().top;\r\n            const clientTop = this.elementRef.nativeElement.clientTop;\r\n\r\n            // get vertical position for selected element\r\n            this._offsetTop = viewportTop + this.scroll.pos - clientTop;\r\n        } else {\r\n            this._offsetTop = 0;\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2022/directives/animate-on-scroll/cmat-directives-animate-on-scroll.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1kaXJlY3RpdmVzLWFuaW1hdGUtb24tc2Nyb2xsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9kaXJlY3RpdmVzL2FuaW1hdGUtb24tc2Nyb2xsL2NtYXQtZGlyZWN0aXZlcy1hbmltYXRlLW9uLXNjcm9sbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/directives/animate-on-scroll/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './animate-on-scroll.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvZGlyZWN0aXZlcy9hbmltYXRlLW9uLXNjcm9sbC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FuaW1hdGUtb24tc2Nyb2xsLmRpcmVjdGl2ZSc7XHJcbiJdfQ==

package/esm2022/directives/animate-on-scroll/scroll.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { Subscription, EMPTY, fromEvent } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ScrollService {
+    constructor() {
+        this._scrollSub = new Subscription();
+        this._resizeSub = new Subscription();
+        // set initial value
+        this.manageScrollPos();
+        // create observable that we can subscribe to from component or directive
+        this.scrollObs =
+            typeof window !== 'undefined' ? fromEvent(window, 'scroll') : EMPTY;
+        // initiate subscription to update values
+        this._scrollSub = this.scrollObs.subscribe(() => this.manageScrollPos());
+        // create observable for changes in screen size
+        this.resizeObs =
+            typeof window !== 'undefined' ? fromEvent(window, 'resize') : EMPTY;
+        // initiate subscription to update values
+        this._resizeSub = this.resizeObs.subscribe(() => this.manageScrollPos());
+    }
+    ngOnDestroy() {
+        this._scrollSub.unsubscribe();
+        this._resizeSub.unsubscribe();
+    }
+    manageScrollPos() {
+        // update service property
+        this.pos = typeof window !== 'undefined' ? window.pageYOffset : 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: ScrollService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: ScrollService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/autofocus/autofocus.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CmatAutofocusDirective {
+    constructor(element) {
+        this.element = element;
+    }
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatAutofocusDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatAutofocusDirective, isStandalone: true, selector: "[cmatAutofocus]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatAutofocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cmatAutofocus]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2ZvY3VzLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvZGlyZWN0aXZlcy9hdXRvZm9jdXMvYXV0b2ZvY3VzLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFjLE1BQU0sZUFBZSxDQUFDOztBQU90RCxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLFlBQW1CLE9BQW1CO1FBQW5CLFlBQU8sR0FBUCxPQUFPLENBQVk7SUFBSSxDQUFDO0lBRTNDLEtBQUs7UUFDSCxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNyQyxDQUFDOzhHQUxVLHNCQUFzQjtrR0FBdEIsc0JBQXNCOzsyRkFBdEIsc0JBQXNCO2tCQUpsQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxpQkFBaUI7b0JBQzNCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBGb2N1c2FibGVPcHRpb24gfSBmcm9tICdAYW5ndWxhci9jZGsvYTExeSc7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICBzZWxlY3RvcjogJ1tjbWF0QXV0b2ZvY3VzXScsXHJcbiAgc3RhbmRhbG9uZTogdHJ1ZVxyXG59KVxyXG5leHBvcnQgY2xhc3MgQ21hdEF1dG9mb2N1c0RpcmVjdGl2ZSBpbXBsZW1lbnRzIEZvY3VzYWJsZU9wdGlvbiB7XHJcbiAgY29uc3RydWN0b3IocHVibGljIGVsZW1lbnQ6IEVsZW1lbnRSZWYpIHsgfVxyXG5cclxuICBmb2N1cygpOiB2b2lkIHtcclxuICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmZvY3VzKCk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2022/directives/autofocus/cmat-directives-autofocus.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1kaXJlY3RpdmVzLWF1dG9mb2N1cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvZGlyZWN0aXZlcy9hdXRvZm9jdXMvY21hdC1kaXJlY3RpdmVzLWF1dG9mb2N1cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/directives/autofocus/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './autofocus.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvZGlyZWN0aXZlcy9hdXRvZm9jdXMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRvZm9jdXMuZGlyZWN0aXZlJztcclxuIl19

package/esm2022/directives/debounce/abstract-debounce.directive.mjs

@@ -0,0 +1,34 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, takeUntil, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class AbstractDebounceDirective {
+    constructor() {
+        this.debounceTime = 500;
+        this.emitChanged = new EventEmitter();
+        this.emitEvent$ = new Subject();
+        this.subscription$ = new Subject();
+    }
+    ngOnInit() {
+        this.emitEvent$
+            .pipe(takeUntil(this.subscription$), debounceTime(this.debounceTime), distinctUntilChanged(), tap(value => this.emitChange(value)))
+            .subscribe();
+    }
+    emitChange(value) {
+        this.emitChanged.emit(value);
+    }
+    ngOnDestroy() {
+        this.subscription$.next();
+        this.subscription$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: AbstractDebounceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: AbstractDebounceDirective, inputs: { debounceTime: "debounceTime" }, outputs: { emitChanged: "emitChanged" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: AbstractDebounceDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { debounceTime: [{
+                type: Input
+            }], emitChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/debounce/cmat-directives-debounce.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1kaXJlY3RpdmVzLWRlYm91bmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9kaXJlY3RpdmVzL2RlYm91bmNlL2NtYXQtZGlyZWN0aXZlcy1kZWJvdW5jZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/directives/debounce/debounce-click.directive.mjs

@@ -0,0 +1,25 @@
+import { Directive, HostListener } from '@angular/core';
+import { AbstractDebounceDirective } from './abstract-debounce.directive';
+import * as i0 from "@angular/core";
+export class CmatDebounceClickDirective extends AbstractDebounceDirective {
+    constructor() {
+        super();
+    }
+    onKeyUp(event) {
+        event.preventDefault();
+        this.emitEvent$.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDebounceClickDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatDebounceClickDirective, isStandalone: true, selector: "[cmatDebounceClick]", host: { listeners: { "click": "onKeyUp($event)" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDebounceClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cmatDebounceClick]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { onKeyUp: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2UtY2xpY2suZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9kaXJlY3RpdmVzL2RlYm91bmNlL2RlYm91bmNlLWNsaWNrLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN4RCxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7QUFNMUUsTUFBTSxPQUFPLDBCQUEyQixTQUFRLHlCQUF5QjtJQUNyRTtRQUNJLEtBQUssRUFBRSxDQUFDO0lBQ1osQ0FBQztJQUdNLE9BQU8sQ0FBQyxLQUFVO1FBQ3JCLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNoQyxDQUFDOzhHQVRRLDBCQUEwQjtrR0FBMUIsMEJBQTBCOzsyRkFBMUIsMEJBQTBCO2tCQUp0QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxxQkFBcUI7b0JBQy9CLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjt3REFPVSxPQUFPO3NCQURiLFlBQVk7dUJBQUMsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0TGlzdGVuZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQWJzdHJhY3REZWJvdW5jZURpcmVjdGl2ZSB9IGZyb20gJy4vYWJzdHJhY3QtZGVib3VuY2UuZGlyZWN0aXZlJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6ICdbY21hdERlYm91bmNlQ2xpY2tdJyxcclxuICAgIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIENtYXREZWJvdW5jZUNsaWNrRGlyZWN0aXZlIGV4dGVuZHMgQWJzdHJhY3REZWJvdW5jZURpcmVjdGl2ZSB7XHJcbiAgICBjb25zdHJ1Y3RvcigpIHtcclxuICAgICAgICBzdXBlcigpO1xyXG4gICAgfVxyXG5cclxuICAgIEBIb3N0TGlzdGVuZXIoJ2NsaWNrJywgWyckZXZlbnQnXSlcclxuICAgIHB1YmxpYyBvbktleVVwKGV2ZW50OiBhbnkpOiB2b2lkIHtcclxuICAgICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xyXG4gICAgICAgIHRoaXMuZW1pdEV2ZW50JC5uZXh0KGV2ZW50KTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2022/directives/debounce/debounce-keyup.directive.mjs

@@ -0,0 +1,25 @@
+import { Directive, HostListener } from '@angular/core';
+import { AbstractDebounceDirective } from './abstract-debounce.directive';
+import * as i0 from "@angular/core";
+export class CmatDebounceKeyupDirective extends AbstractDebounceDirective {
+    constructor() {
+        super();
+    }
+    onKeyUp(event) {
+        event.preventDefault();
+        this.emitEvent$.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDebounceKeyupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatDebounceKeyupDirective, isStandalone: true, selector: "input[cmatDebounceKeyUp]", host: { listeners: { "keyup": "onKeyUp($event)" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDebounceKeyupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[cmatDebounceKeyUp]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { onKeyUp: [{
+                type: HostListener,
+                args: ['keyup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2Uta2V5dXAuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9kaXJlY3RpdmVzL2RlYm91bmNlL2RlYm91bmNlLWtleXVwLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLFlBQVksRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN0RCxPQUFPLEVBQUMseUJBQXlCLEVBQUMsTUFBTSwrQkFBK0IsQ0FBQzs7QUFNeEUsTUFBTSxPQUFPLDBCQUEyQixTQUFRLHlCQUF5QjtJQUNyRTtRQUNJLEtBQUssRUFBRSxDQUFDO0lBQ1osQ0FBQztJQUdNLE9BQU8sQ0FBQyxLQUFVO1FBQ3JCLEtBQUssQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNoQyxDQUFDOzhHQVRRLDBCQUEwQjtrR0FBMUIsMEJBQTBCOzsyRkFBMUIsMEJBQTBCO2tCQUp0QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSwwQkFBMEI7b0JBQ3BDLFVBQVUsRUFBRSxJQUFJO2lCQUNuQjt3REFPVSxPQUFPO3NCQURiLFlBQVk7dUJBQUMsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIEhvc3RMaXN0ZW5lcn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7QWJzdHJhY3REZWJvdW5jZURpcmVjdGl2ZX0gZnJvbSAnLi9hYnN0cmFjdC1kZWJvdW5jZS5kaXJlY3RpdmUnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgICBzZWxlY3RvcjogJ2lucHV0W2NtYXREZWJvdW5jZUtleVVwXScsXHJcbiAgICBzdGFuZGFsb25lOiB0cnVlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDbWF0RGVib3VuY2VLZXl1cERpcmVjdGl2ZSBleHRlbmRzIEFic3RyYWN0RGVib3VuY2VEaXJlY3RpdmUge1xyXG4gICAgY29uc3RydWN0b3IoKSB7XHJcbiAgICAgICAgc3VwZXIoKTtcclxuICAgIH1cclxuXHJcbiAgICBASG9zdExpc3RlbmVyKCdrZXl1cCcsIFsnJGV2ZW50J10pXHJcbiAgICBwdWJsaWMgb25LZXlVcChldmVudDogYW55KTogdm9pZCB7XHJcbiAgICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTtcclxuICAgICAgICB0aGlzLmVtaXRFdmVudCQubmV4dChldmVudCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2022/directives/debounce/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './debounce-click.directive';
+export * from './debounce-keyup.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvZGlyZWN0aXZlcy9kZWJvdW5jZS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGVib3VuY2UtY2xpY2suZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9kZWJvdW5jZS1rZXl1cC5kaXJlY3RpdmUnO1xyXG4iXX0=

package/esm2022/directives/digit-only/cmat-directives-digit-only.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1kaXJlY3RpdmVzLWRpZ2l0LW9ubHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbWF0L2RpcmVjdGl2ZXMvZGlnaXQtb25seS9jbWF0LWRpcmVjdGl2ZXMtZGlnaXQtb25seS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19