cmat 0.0.3

package/components/transfer-picker/transfer-picker-target/transfer-picker-target.component.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import { CmatTransferItemFlatNode } from '../interface';
+import * as i0 from "@angular/core";
+export declare class CmatTransferPickerTargetComponent {
+    selectedList: Array<CmatTransferItemFlatNode>;
+    clearItemChange: EventEmitter<CmatTransferItemFlatNode>;
+    constructor();
+    clearItem(item: CmatTransferItemFlatNode): void;
+    trackByFn(index: number, item: CmatTransferItemFlatNode): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerTargetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerTargetComponent, "cmat-transfer-picker-target", ["cmatTransferPickerTarget"], { "selectedList": { "alias": "selectedList"; "required": false; }; }, { "clearItemChange": "clearItemChange"; }, never, never, true, never>;
+}

package/components/transfer-picker/transfer-picker-target/transfer-picker-target.component.scss

@@ -0,0 +1,27 @@
+.transfer-picker-target {
+    @apply h-full p-0 shadow bg-card;
+    width: 276px;
+
+    .mat-mdc-card-header {
+        margin-bottom: -8px;
+    }
+
+    &-title {
+        @apply text-lg mb-0;
+        padding: 12px 0;
+    }
+
+    &-item {
+        @apply w-full;
+    }
+
+    &-scroll-wrapper {
+        height: 356px;
+    }
+
+    &-empty {
+        @apply text-center;
+        margin-top: 20px;
+        color: rgba(0,0,0,0.25);
+    }
+}

package/components/transfer-picker/transfer-picker.component.d.ts

@@ -0,0 +1,28 @@
+import { AfterViewInit, ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { CmatTransferFilterItem, CmatTransferItemFlatNode, CmatTransferItemNode } from './interface';
+import { CmatTransferPickerService } from './transfer-picker.service';
+import { CmatTransferPickerSourceComponent } from './transfer-picker-source/transfer-picker-source.component';
+import * as i0 from "@angular/core";
+export declare class CmatTransferPickerComponent implements OnInit, AfterViewInit {
+    private _service;
+    private _changeDetectorRef;
+    title: string;
+    filterable: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    dataSource: Array<CmatTransferItemNode>;
+    filters: Array<CmatTransferFilterItem>;
+    selectedValues: Array<string>;
+    selectChange: EventEmitter<Array<CmatTransferItemFlatNode>>;
+    source: CmatTransferPickerSourceComponent;
+    selectedList: Array<CmatTransferItemFlatNode>;
+    constructor(_service: CmatTransferPickerService, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    pick(): void;
+    reset(): void;
+    onClearItemChange(item: CmatTransferItemFlatNode): void;
+    private _emitterChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatTransferPickerComponent, "cmat-transfer-picker", ["cmatTransferPicker"], { "title": { "alias": "title"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "selectedValues": { "alias": "selectedValues"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+}

package/components/transfer-picker/transfer-picker.component.scss

@@ -0,0 +1,8 @@
+cmat-transfer-picker-container {
+    @apply h-full overflow-hidden p-4 flex flex-col md:flex-row flex-nowrap justify-items-center items-center gap-2;
+
+    cmat-transfer-picker-source,
+    cmat-transfer-picker-target {
+        @apply h-full;
+    }
+}

package/components/transfer-picker/transfer-picker.service.d.ts

@@ -0,0 +1,31 @@
+import { BehaviorSubject } from 'rxjs';
+import { CmatSourceOptions, CmatTransferFilterData, CmatTransferFilterItem, CmatTransferItemNode } from './interface';
+import * as i0 from "@angular/core";
+export declare class CmatTransferPickerService {
+    dataSourceChange: BehaviorSubject<Array<CmatTransferItemNode>>;
+    filtersChange: BehaviorSubject<Array<CmatTransferFilterItem>>;
+    sourceOptionsChange: BehaviorSubject<CmatSourceOptions | void>;
+    selectedValuesChange: BehaviorSubject<Array<string>>;
+    private _dataSource;
+    private _filterData;
+    private _keyword;
+    private _originalDataSource;
+    private _filteredDataSource;
+    private _compareMap;
+    private _conditionMap;
+    constructor();
+    get dataSource(): Array<CmatTransferItemNode>;
+    set dataSource(data: Array<CmatTransferItemNode>);
+    set sourceOptions(value: CmatSourceOptions);
+    set selectedValues(value: Array<string>);
+    filterDataSource({ filterData, keyword }: {
+        filterData?: CmatTransferFilterData;
+        keyword?: string;
+    }): void;
+    resetDataSource(): void;
+    private _filterDataSourceByType;
+    private _setFilteredDataSourceByFilters;
+    private _setFilteredDataSourceByKeyword;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatTransferPickerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatTransferPickerService>;
+}

package/directives/animate-on-scroll/animate-on-scroll.directive.d.ts

@@ -0,0 +1,29 @@
+import { AfterViewInit, ElementRef, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { ScrollService } from './scroll.service';
+import * as i0 from "@angular/core";
+export declare class CmatAnimationOnScrollDirective implements OnInit, OnDestroy, AfterViewInit {
+    private elementRef;
+    private renderer;
+    private scroll;
+    animationName: string | null;
+    offset: number;
+    useScroll?: boolean;
+    threshold?: number;
+    private _offsetTop;
+    private _isVisible;
+    private _winHeight;
+    private _scrollSub;
+    private _resizeSub;
+    constructor(elementRef: ElementRef, renderer: Renderer2, scroll: ScrollService);
+    private get id();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private manageVisibility;
+    private addAnimationClass;
+    private setClass;
+    private getWinHeight;
+    private getOffsetTop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAnimationOnScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAnimationOnScrollDirective, "[cmatAnimateOnScroll]", never, { "animationName": { "alias": "animationName"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "useScroll": { "alias": "useScroll"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/animate-on-scroll/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="cmat/directives/animate-on-scroll" />
+export * from './public-api';

package/directives/animate-on-scroll/public-api.d.ts

@@ -0,0 +1 @@
+export * from './animate-on-scroll.directive';

package/directives/animate-on-scroll/scroll.service.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ScrollService implements OnDestroy {
+    scrollObs: Observable<any>;
+    resizeObs: Observable<any>;
+    pos: number;
+    private _scrollSub;
+    private _resizeSub;
+    constructor();
+    ngOnDestroy(): void;
+    private manageScrollPos;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollService>;
+}

package/directives/autofocus/autofocus.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef } from '@angular/core';
+import { FocusableOption } from '@angular/cdk/a11y';
+import * as i0 from "@angular/core";
+export declare class CmatAutofocusDirective implements FocusableOption {
+    element: ElementRef;
+    constructor(element: ElementRef);
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatAutofocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatAutofocusDirective, "[cmatAutofocus]", never, {}, {}, never, never, true, never>;
+}

package/directives/autofocus/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="cmat/directives/autofocus" />
+export * from './public-api';

package/directives/autofocus/public-api.d.ts

@@ -0,0 +1 @@
+export * from './autofocus.directive';

package/directives/debounce/abstract-debounce.directive.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare abstract class AbstractDebounceDirective implements OnInit, OnDestroy {
+    debounceTime: number;
+    emitChanged: EventEmitter<any>;
+    emitEvent$: Subject<any>;
+    subscription$: Subject<void>;
+    constructor();
+    ngOnInit(): void;
+    emitChange(value: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDebounceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDebounceDirective, never, never, { "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "emitChanged": "emitChanged"; }, never, never, false, never>;
+}

package/directives/debounce/debounce-click.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractDebounceDirective } from './abstract-debounce.directive';
+import * as i0 from "@angular/core";
+export declare class CmatDebounceClickDirective extends AbstractDebounceDirective {
+    constructor();
+    onKeyUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceClickDirective, "[cmatDebounceClick]", never, {}, {}, never, never, true, never>;
+}

package/directives/debounce/debounce-keyup.directive.d.ts

@@ -0,0 +1,8 @@
+import { AbstractDebounceDirective } from './abstract-debounce.directive';
+import * as i0 from "@angular/core";
+export declare class CmatDebounceKeyupDirective extends AbstractDebounceDirective {
+    constructor();
+    onKeyUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceKeyupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceKeyupDirective, "input[cmatDebounceKeyUp]", never, {}, {}, never, never, true, never>;
+}

package/directives/debounce/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="cmat/directives/debounce" />
+export * from './public-api';

package/directives/debounce/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './debounce-click.directive';
+export * from './debounce-keyup.directive';

package/directives/digit-only/digit-only.directive.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CmatDigitOnlyDirective implements OnChanges {
+    el: ElementRef;
+    decimal: boolean;
+    decimalSeparator: string;
+    allowNegatives: boolean;
+    allowPaste: boolean;
+    negativeSign: string;
+    min: number;
+    max: number;
+    pattern?: string | RegExp;
+    inputElement: HTMLInputElement;
+    private _regex;
+    private _hasDecimalPoint;
+    private _hasNegativeSign;
+    private _navigationKeys;
+    constructor(el: ElementRef);
+    onBeforeInput(e: InputEvent): any;
+    onKeyDown(e: KeyboardEvent): any;
+    onPaste(event: any): void;
+    onDrop(event: DragEvent): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _pasteData;
+    private _insertAtCursor;
+    private _triggerEvent;
+    private _sanitizeInput;
+    private _getNegativeSignRegExp;
+    private _isValidDecimal;
+    private _getSelection;
+    private _forecastValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDigitOnlyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDigitOnlyDirective, "[cmatDigitOnly]", never, { "decimal": { "alias": "decimal"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; "allowNegatives": { "alias": "allowNegatives"; "required": false; }; "allowPaste": { "alias": "allowPaste"; "required": false; }; "negativeSign": { "alias": "negativeSign"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/digit-only/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="cmat/directives/digit-only" />
+export * from './public-api';

package/directives/digit-only/mask.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CmatMaskDirective implements OnInit {
+    el: ElementRef;
+    inputElement: HTMLInputElement;
+    regex: RegExp;
+    private _navigationKeys;
+    constructor(el: ElementRef);
+    onKeyDown(e: KeyboardEvent): void;
+    ngOnInit(): void;
+    private _forecastValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatMaskDirective, "[cmatMask]", never, {}, {}, never, never, true, never>;
+}

package/directives/digit-only/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './digit-only.directive';
+export * from './mask.directive';

package/directives/equal-validator/equal-validator.directive.d.ts

@@ -0,0 +1,14 @@
+import { Validator, AbstractControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class CmatEqualValidatorDirective implements Validator {
+    private _validateEqual;
+    private _reverse;
+    constructor(_validateEqual: string, _reverse: string);
+    private static _validateNoReverse;
+    private static _validateReverse;
+    validate(c: AbstractControl): {
+        [key: string]: any;
+    } | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatEqualValidatorDirective, [{ attribute: "cmatValidateEqual"; }, { attribute: "reverse"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatEqualValidatorDirective, "[cmatValidateEqual][formControlName],[cmatValidateEqual][formControl],[cmatValidateEqual][ngModel]", never, {}, {}, never, never, true, never>;
+}

package/directives/equal-validator/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="cmat/directives/equal-validator" />
+export * from './public-api';

package/directives/equal-validator/public-api.d.ts

@@ -0,0 +1 @@
+export * from './equal-validator.directive';

package/esm2022/animations/cmat-animations.mjs

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

package/esm2022/animations/defaults.mjs

@@ -0,0 +1,12 @@
+export class CmatAnimationCurves {
+    static { this.standard = 'cubic-bezier(0.4, 0.0, 0.2, 1)'; }
+    static { this.deceleration = 'cubic-bezier(0.0, 0.0, 0.2, 1)'; }
+    static { this.acceleration = 'cubic-bezier(0.4, 0.0, 1, 1)'; }
+    static { this.sharp = 'cubic-bezier(0.4, 0.0, 0.6, 1)'; }
+}
+export class CmatAnimationDurations {
+    static { this.complex = '375ms'; }
+    static { this.entering = '225ms'; }
+    static { this.exiting = '195ms'; }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jbWF0L2FuaW1hdGlvbnMvZGVmYXVsdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLG1CQUFtQjthQUNyQixhQUFRLEdBQUcsZ0NBQWdDLENBQUM7YUFDNUMsaUJBQVksR0FBRyxnQ0FBZ0MsQ0FBQzthQUNoRCxpQkFBWSxHQUFHLDhCQUE4QixDQUFDO2FBQzlDLFVBQUssR0FBRyxnQ0FBZ0MsQ0FBQzs7QUFHcEQsTUFBTSxPQUFPLHNCQUFzQjthQUN4QixZQUFPLEdBQUcsT0FBTyxDQUFDO2FBQ2xCLGFBQVEsR0FBRyxPQUFPLENBQUM7YUFDbkIsWUFBTyxHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBDbWF0QW5pbWF0aW9uQ3VydmVzIHtcclxuICAgIHN0YXRpYyBzdGFuZGFyZCA9ICdjdWJpYy1iZXppZXIoMC40LCAwLjAsIDAuMiwgMSknO1xyXG4gICAgc3RhdGljIGRlY2VsZXJhdGlvbiA9ICdjdWJpYy1iZXppZXIoMC4wLCAwLjAsIDAuMiwgMSknO1xyXG4gICAgc3RhdGljIGFjY2VsZXJhdGlvbiA9ICdjdWJpYy1iZXppZXIoMC40LCAwLjAsIDEsIDEpJztcclxuICAgIHN0YXRpYyBzaGFycCA9ICdjdWJpYy1iZXppZXIoMC40LCAwLjAsIDAuNiwgMSknO1xyXG59XHJcblxyXG5leHBvcnQgY2xhc3MgQ21hdEFuaW1hdGlvbkR1cmF0aW9ucyB7XHJcbiAgICBzdGF0aWMgY29tcGxleCA9ICczNzVtcyc7XHJcbiAgICBzdGF0aWMgZW50ZXJpbmcgPSAnMjI1bXMnO1xyXG4gICAgc3RhdGljIGV4aXRpbmcgPSAnMTk1bXMnO1xyXG59XHJcbiJdfQ==

package/esm2022/animations/drop.mjs

@@ -0,0 +1,26 @@
+import { animate, state, style, transition, trigger } from '@angular/animations';
+export const dropdown = trigger('dropdown', [
+    state('*', style({
+        opacity: 0,
+        height: 0,
+        border: 0,
+        padding: 0,
+        visibility: 'hidden',
+    })),
+    state('false', style({
+        opacity: 0,
+        height: 0,
+        border: 0,
+        padding: 0,
+        visibility: 'hidden',
+    })),
+    state('true', style({
+        opacity: 1,
+        height: '*',
+        border: '*',
+        padding: '*',
+        visibility: 'inherit',
+    })),
+    transition('* => *', animate('250ms ease-out'))
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/animations/expand-collapse.mjs

@@ -0,0 +1,17 @@
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { CmatAnimationCurves, CmatAnimationDurations } from './defaults';
+const expandCollapse = trigger('expandCollapse', [
+    state('void, collapsed', style({
+        height: '0'
+    })),
+    state('*, expanded', style('*')),
+    // Prevent the transition if the state is false
+    transition('void <=> false, collapsed <=> false, expanded <=> false', []),
+    transition('void <=> *, collapsed <=> expanded', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`
+        }
+    })
+]);
+export { expandCollapse };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/animations/fade.mjs

@@ -0,0 +1,170 @@
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { CmatAnimationCurves, CmatAnimationDurations } from './defaults';
+const fadeIn = trigger('fadeIn', [
+    state('void', style({
+        opacity: 0
+    })),
+    state('*', style({
+        opacity: 1
+    })),
+    // Prevent the transition if the state is false
+    transition('void => false', []),
+    transition('void => *', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`
+        }
+    })
+]);
+const fadeInTop = trigger('fadeInTop', [
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(0, -100%, 0)'
+    })),
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('void => false', []),
+    transition('void => *', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`
+        }
+    })
+]);
+const fadeInBottom = trigger('fadeInBottom', [
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(0, 100%, 0)'
+    })),
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('void => false', []),
+    transition('void => *', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`
+        }
+    })
+]);
+const fadeInLeft = trigger('fadeInLeft', [
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(-100%, 0, 0)'
+    })),
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('void => false', []),
+    transition('void => *', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`
+        }
+    })
+]);
+const fadeInRight = trigger('fadeInRight', [
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(100%, 0, 0)'
+    })),
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('void => false', []),
+    transition('void => *', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`
+        }
+    })
+]);
+const fadeOut = trigger('fadeOut', [
+    state('*', style({
+        opacity: 1
+    })),
+    state('void', style({
+        opacity: 0
+    })),
+    // Prevent the transition if the state is false
+    transition('false => void', []),
+    transition('* => void', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`
+        }
+    })
+]);
+const fadeOutTop = trigger('fadeOutTop', [
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(0, -100%, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('false => void', []),
+    transition('* => void', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`
+        }
+    })
+]);
+const fadeOutBottom = trigger('fadeOutBottom', [
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(0, 100%, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('false => void', []),
+    transition('* => void', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`
+        }
+    })
+]);
+const fadeOutLeft = trigger('fadeOutLeft', [
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(-100%, 0, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('false => void', []),
+    transition('* => void', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`
+        }
+    })
+]);
+const fadeOutRight = trigger('fadeOutRight', [
+    state('*', style({
+        opacity: 1,
+        transform: 'translate3d(0, 0, 0)'
+    })),
+    state('void', style({
+        opacity: 0,
+        transform: 'translate3d(100%, 0, 0)'
+    })),
+    // Prevent the transition if the state is false
+    transition('false => void', []),
+    transition('* => void', animate('{{timings}}'), {
+        params: {
+            timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`
+        }
+    })
+]);
+export { fadeIn, fadeInTop, fadeInBottom, fadeInLeft, fadeInRight, fadeOut, fadeOutTop, fadeOutBottom, fadeOutLeft, fadeOutRight };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fade.js","sourceRoot":"","sources":["../../../../projects/cmat/animations/fade.ts"],"names":[],"mappings":"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","sourcesContent":["import {animate, state, style, transition, trigger} from '@angular/animations';\r\nimport {CmatAnimationCurves, CmatAnimationDurations} from './defaults';\r\n\r\nconst fadeIn = trigger('fadeIn',\r\n    [\r\n        state('void',\r\n            style({\r\n                opacity: 0\r\n            })\r\n        ),\r\n\r\n        state('*',\r\n            style({\r\n                opacity: 1\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('void => false', []),\r\n\r\n        transition('void => *', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeInTop = trigger('fadeInTop',\r\n    [\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(0, -100%, 0)'\r\n            })\r\n        ),\r\n\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('void => false', []),\r\n\r\n        transition('void => *', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeInBottom = trigger('fadeInBottom',\r\n    [\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(0, 100%, 0)'\r\n            })\r\n        ),\r\n\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('void => false', []),\r\n\r\n        transition('void => *', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeInLeft = trigger('fadeInLeft',\r\n    [\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(-100%, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('void => false', []),\r\n\r\n        transition('void => *', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeInRight = trigger('fadeInRight',\r\n    [\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(100%, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('void => false', []),\r\n\r\n        transition('void => *', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.entering} ${CmatAnimationCurves.deceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeOut = trigger('fadeOut',\r\n    [\r\n        state('*',\r\n            style({\r\n                opacity: 1\r\n            })\r\n        ),\r\n\r\n        state('void',\r\n            style({\r\n                opacity: 0\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('false => void', []),\r\n\r\n        transition('* => void', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeOutTop = trigger('fadeOutTop',\r\n    [\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(0, -100%, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('false => void', []),\r\n\r\n        transition('* => void', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeOutBottom = trigger('fadeOutBottom',\r\n    [\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(0, 100%, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('false => void', []),\r\n\r\n        transition('* => void', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeOutLeft = trigger('fadeOutLeft',\r\n    [\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(-100%, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('false => void', []),\r\n\r\n        transition('* => void', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nconst fadeOutRight = trigger('fadeOutRight',\r\n    [\r\n        state('*',\r\n            style({\r\n                opacity: 1,\r\n                transform: 'translate3d(0, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        state('void',\r\n            style({\r\n                opacity: 0,\r\n                transform: 'translate3d(100%, 0, 0)'\r\n            })\r\n        ),\r\n\r\n        // Prevent the transition if the state is false\r\n        transition('false => void', []),\r\n\r\n        transition('* => void', animate('{{timings}}'),\r\n            {\r\n                params: {\r\n                    timings: `${CmatAnimationDurations.exiting} ${CmatAnimationCurves.acceleration}`\r\n                }\r\n            }\r\n        )\r\n    ]\r\n);\r\n\r\nexport {fadeIn, fadeInTop, fadeInBottom, fadeInLeft, fadeInRight, fadeOut, fadeOutTop, fadeOutBottom, fadeOutLeft, fadeOutRight};\r\n"]}

package/esm2022/animations/public-api.mjs

@@ -0,0 +1,19 @@
+import { dropdown } from './drop';
+import { expandCollapse } from './expand-collapse';
+import { fadeIn, fadeInBottom, fadeInLeft, fadeInRight, fadeInTop, fadeOut, fadeOutBottom, fadeOutLeft, fadeOutRight, fadeOutTop } from './fade';
+import { shake } from './shake';
+import { slideInBottom, slideInLeft, slideInRight, slideInTop, slideOutBottom, slideOutLeft, slideOutRight, slideOutTop } from './slide';
+import { zoomIn, zoomOut } from './zoom';
+import { transform } from './transform';
+export const cmatAnimations = [
+    expandCollapse,
+    fadeIn, fadeInTop, fadeInBottom, fadeInLeft, fadeInRight,
+    fadeOut, fadeOutTop, fadeOutBottom, fadeOutLeft, fadeOutRight,
+    shake,
+    slideInTop, slideInBottom, slideInLeft, slideInRight,
+    slideOutTop, slideOutBottom, slideOutLeft, slideOutRight,
+    zoomIn, zoomOut,
+    dropdown,
+    transform
+];
+//# sourceMappingURL=data:application/json;base64,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