@mintplayer/ng-swiper 15.1.0

package/README.md

@@ -0,0 +1,7 @@
+# mintplayer-ng-swiper
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test mintplayer-ng-swiper` to execute the unit tests.

package/esm2020/index.mjs

@@ -0,0 +1,4 @@
+export * from './lib/swiper.module';
+export * from './lib/directives';
+export * from './lib/interfaces';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctc3dpcGVyL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3N3aXBlci5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGlyZWN0aXZlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzJzsiXX0=

package/esm2020/lib/directives/index.mjs

@@ -0,0 +1,3 @@
+export * from './swipe/swipe.directive';
+export * from './swipe-container/swipe-container.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctc3dpcGVyL3NyYy9saWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsNkNBQTZDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3N3aXBlL3N3aXBlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3N3aXBlLWNvbnRhaW5lci9zd2lwZS1jb250YWluZXIuZGlyZWN0aXZlJzsiXX0=

package/esm2020/lib/directives/swipe/swipe.directive.mjs

@@ -0,0 +1,93 @@
+import { Directive, ElementRef, HostBinding, HostListener, Input } from "@angular/core";
+import { BehaviorSubject, combineLatest, filter, take } from "rxjs";
+import { BsSwipeContainerDirective } from "../swipe-container/swipe-container.directive";
+import * as i0 from "@angular/core";
+import * as i1 from "../swipe-container/swipe-container.directive";
+export class BsSwipeDirective {
+    constructor(container, element) {
+        this.container = container;
+        this.slideHeight$ = new BehaviorSubject(0);
+        //#region Offside
+        this.offside = false;
+        //#endregion
+        this.alignTopClass = true;
+        this.element = element;
+    }
+    onTouchStart(ev) {
+        if (ev.touches.length === 1) {
+            ev.preventDefault();
+            this.container.pendingAnimation?.finish();
+            setTimeout(() => {
+                this.container.startTouch$.next({
+                    position: {
+                        x: ev.touches[0].clientX,
+                        y: ev.touches[0].clientY,
+                    },
+                    timestamp: Date.now(),
+                });
+                this.container.lastTouch$.next({
+                    position: {
+                        x: ev.touches[0].clientX,
+                        y: ev.touches[0].clientY,
+                    },
+                    isTouching: true,
+                });
+            }, 20);
+        }
+    }
+    onTouchMove(ev) {
+        this.container.lastTouch$.next({
+            position: {
+                x: ev.touches[0].clientX,
+                y: ev.touches[0].clientY,
+            },
+            isTouching: true,
+        });
+    }
+    onTouchEnd(ev) {
+        combineLatest([this.container.startTouch$, this.container.lastTouch$])
+            .pipe(filter(([startTouch, lastTouch]) => !!startTouch && !!lastTouch))
+            .pipe(take(1))
+            .subscribe(([startTouch, lastTouch]) => {
+            if (!!startTouch && !!lastTouch) {
+                const dx = lastTouch.position.x - startTouch.position.x;
+                this.container.onSwipe(dx);
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this.observer = new ResizeObserver((entries) => {
+            this.slideHeight$.next(entries[0].contentRect.height);
+        });
+        this.observer.observe(this.element.nativeElement);
+    }
+    ngOnDestroy() {
+        if (this.observer) {
+            this.observer.unobserve(this.element.nativeElement);
+            this.observer.disconnect();
+        }
+    }
+}
+BsSwipeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwipeDirective, deps: [{ token: i1.BsSwipeContainerDirective }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+BsSwipeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: BsSwipeDirective, selector: "[bsSwipe]", inputs: { offside: "offside" }, host: { listeners: { "touchstart": "onTouchStart($event)", "touchmove": "onTouchMove($event)", "touchend": "onTouchEnd($event)" }, properties: { "class.align-top": "this.alignTopClass" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwipeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bsSwipe]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BsSwipeContainerDirective }, { type: i0.ElementRef }]; }, propDecorators: { offside: [{
+                type: Input
+            }], alignTopClass: [{
+                type: HostBinding,
+                args: ['class.align-top']
+            }], onTouchStart: [{
+                type: HostListener,
+                args: ['touchstart', ['$event']]
+            }], onTouchMove: [{
+                type: HostListener,
+                args: ['touchmove', ['$event']]
+            }], onTouchEnd: [{
+                type: HostListener,
+                args: ['touchend', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/swipe-container/swipe-container.directive.mjs

@@ -0,0 +1,212 @@
+import { animate, AnimationBuilder, style } from '@angular/animations';
+import { DOCUMENT } from '@angular/common';
+import { ContentChildren, Directive, ElementRef, EventEmitter, forwardRef, HostBinding, Inject, Input, Output, QueryList } from '@angular/core';
+import { BehaviorSubject, combineLatest, filter, map, mergeMap, Subject, take, takeUntil } from 'rxjs';
+import { BsSwipeDirective } from '../swipe/swipe.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/animations";
+export class BsSwipeContainerDirective {
+    constructor(element, animationBuilder, document) {
+        this.animationBuilder = animationBuilder;
+        this.offsetLeft = null;
+        this.offsetRight = null;
+        this.offsetTop = null;
+        this.offsetBottom = null;
+        this.minimumOffset = 50;
+        this.imageIndexChange = new EventEmitter();
+        this.isViewInited$ = new BehaviorSubject(false);
+        this.destroyed$ = new Subject();
+        this.startTouch$ = new BehaviorSubject(null);
+        this.lastTouch$ = new BehaviorSubject(null);
+        this.swipes$ = new BehaviorSubject(null);
+        this.imageIndex$ = new BehaviorSubject(0);
+        this.containerElement = element;
+        this.document = document;
+        this.offset$ = combineLatest([this.startTouch$, this.lastTouch$, this.imageIndex$, this.isViewInited$])
+            .pipe(map(([startTouch, lastTouch, imageIndex, isViewInited]) => {
+            if (!isViewInited) {
+                return (-imageIndex * 100);
+            }
+            else if (!!startTouch && !!lastTouch) {
+                return (-imageIndex * 100 + (lastTouch.position.x - startTouch.position.x) / this.containerElement.nativeElement.clientWidth * 100);
+            }
+            else {
+                return (-imageIndex * 100);
+            }
+        }));
+        this.padLeft$ = this.swipes$.pipe(map(swipes => {
+            if (!swipes) {
+                return 0;
+            }
+            let count = 0;
+            for (const s of swipes) {
+                if (!s.offside) {
+                    break;
+                }
+                else {
+                    count++;
+                }
+            }
+            return count;
+        }));
+        this.padRight$ = this.swipes$.pipe(map(swipes => {
+            if (!swipes) {
+                return 0;
+            }
+            let count = 0;
+            for (const s of swipes.toArray().reverse()) {
+                if (!s.offside) {
+                    break;
+                }
+                else {
+                    count++;
+                }
+            }
+            return count;
+        }));
+        this.offsetLeft$ = combineLatest([this.offset$, this.padLeft$])
+            .pipe(map(([offset, padLeft]) => {
+            return offset - padLeft * 100;
+        }));
+        this.offsetRight$ = combineLatest([this.offset$, this.padLeft$, this.padRight$])
+            .pipe(map(([offset, padLeft, padRight]) => {
+            return -(offset - padLeft * 100) - (padRight - 1) * 100;
+        }));
+        this.offsetLeft$
+            .pipe(takeUntil(this.destroyed$))
+            .subscribe((offsetLeft) => this.offsetLeft = offsetLeft);
+        this.offsetRight$
+            .pipe(takeUntil(this.destroyed$))
+            .subscribe((offsetRight) => this.offsetRight = offsetRight);
+        this.imageIndex$
+            .pipe(takeUntil(this.destroyed$))
+            .subscribe((imageIndex) => this.imageIndexChange.emit(imageIndex));
+        this.actualSwipes$ = this.swipes$
+            .pipe(map(swipes => {
+            if (swipes) {
+                return swipes.filter(swipe => !swipe.offside);
+            }
+            else {
+                return [];
+            }
+        }));
+        this.slideHeights$ = this.actualSwipes$
+            .pipe(filter(swipes => !!swipes))
+            // .pipe(map(swipes => <QueryList<BsSwipeDirective>>swipes))
+            .pipe(mergeMap(swipes => combineLatest(swipes.map(swipe => swipe.slideHeight$))));
+        this.currentSlideHeight$ = combineLatest([this.slideHeights$, this.imageIndex$])
+            .pipe(map(([slideHeights, imageIndex]) => {
+            const maxHeight = Math.max(...slideHeights);
+            const currHeight = slideHeights[imageIndex] ?? maxHeight;
+            return maxHeight - (maxHeight - currHeight) /* / 2*/;
+        }));
+    }
+    set swipes(value) {
+        setTimeout(() => this.swipes$.next(value));
+    }
+    //#region ImageIndex
+    get imageIndex() {
+        return this.imageIndex$.value;
+    }
+    set imageIndex(value) {
+        this.imageIndex$.next(value);
+    }
+    ngAfterViewInit() {
+        this.isViewInited$.next(true);
+    }
+    ngOnDestroy() {
+        this.destroyed$.next(true);
+    }
+    animateToIndexByDx(dx) {
+        combineLatest([this.imageIndex$, this.actualSwipes$]).pipe(take(1))
+            .subscribe(([imageIndex, actualSwipes]) => {
+            const direction = dx > 0 ? 'left' : 'right';
+            let newIndex;
+            if (Math.abs(dx) < this.minimumOffset) {
+                newIndex = imageIndex;
+            }
+            else {
+                newIndex = imageIndex + (direction === 'right' ? 1 : -1);
+            }
+            this.animateToIndex(imageIndex, newIndex, dx, actualSwipes?.length ?? 1);
+        });
+    }
+    animateToIndex(oldIndex, newIndex, dx, totalSlides) {
+        this.pendingAnimation = this.animationBuilder.build([
+            style({ 'margin-left': (-(oldIndex + 1) * this.containerElement.nativeElement.clientWidth + dx) + 'px', 'margin-right': ((oldIndex + 1) * this.containerElement.nativeElement.clientWidth - dx) + 'px' }),
+            animate('500ms ease', style({ 'margin-left': (-(newIndex + 1) * this.containerElement.nativeElement.clientWidth) + 'px', 'margin-right': ((newIndex + 1) * this.containerElement.nativeElement.clientWidth) + 'px' })),
+        ]).create(this.containerElement.nativeElement);
+        this.pendingAnimation.onDone(() => {
+            // Correct the image index
+            if (newIndex === -1) {
+                this.imageIndex$.next(totalSlides - 1);
+            }
+            else if (newIndex === totalSlides) {
+                this.imageIndex$.next(0);
+            }
+            else {
+                this.imageIndex$.next(newIndex);
+            }
+            this.startTouch$.next(null);
+            this.lastTouch$.next(null);
+            this.pendingAnimation?.destroy();
+            this.pendingAnimation = undefined;
+        });
+        this.pendingAnimation.play();
+    }
+    onSwipe(dx) {
+        this.animateToIndexByDx(dx);
+    }
+    previous() {
+        this.pendingAnimation?.finish();
+        combineLatest([this.actualSwipes$, this.imageIndex$]).pipe(take(1)).subscribe(([actualSwipes, imageIndex]) => {
+            setTimeout(() => this.animateToIndex(imageIndex, imageIndex - 1, 0, actualSwipes?.length ?? 1), 20);
+        });
+    }
+    next() {
+        this.pendingAnimation?.finish();
+        combineLatest([this.actualSwipes$, this.imageIndex$]).pipe(take(1)).subscribe(([actualSwipes, imageIndex]) => {
+            setTimeout(() => this.animateToIndex(imageIndex, imageIndex + 1, 0, actualSwipes?.length ?? 1), 20);
+        });
+    }
+    goto(index) {
+        combineLatest([this.actualSwipes$, this.imageIndex$]).pipe(take(1)).subscribe(([actualSwipes, imageIndex]) => {
+            this.pendingAnimation?.finish();
+            setTimeout(() => this.animateToIndex(imageIndex, index, 0, actualSwipes?.length ?? 1), 20);
+        });
+    }
+}
+BsSwipeContainerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwipeContainerDirective, deps: [{ token: i0.ElementRef }, { token: i1.AnimationBuilder }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+BsSwipeContainerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: BsSwipeContainerDirective, selector: "[bsSwipeContainer]", inputs: { minimumOffset: "minimumOffset", imageIndex: "imageIndex" }, outputs: { imageIndexChange: "imageIndexChange" }, host: { properties: { "style.margin-left.%": "this.offsetLeft", "style.margin-right.%": "this.offsetRight", "style.margin-top.%": "this.offsetTop", "style.margin-bottom.%": "this.offsetBottom" } }, queries: [{ propertyName: "swipes", predicate: i0.forwardRef(function () { return BsSwipeDirective; }) }], exportAs: ["bsSwipeContainer"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwipeContainerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bsSwipeContainer]',
+                    exportAs: 'bsSwipeContainer'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.AnimationBuilder }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { offsetLeft: [{
+                type: HostBinding,
+                args: ['style.margin-left.%']
+            }], offsetRight: [{
+                type: HostBinding,
+                args: ['style.margin-right.%']
+            }], offsetTop: [{
+                type: HostBinding,
+                args: ['style.margin-top.%']
+            }], offsetBottom: [{
+                type: HostBinding,
+                args: ['style.margin-bottom.%']
+            }], swipes: [{
+                type: ContentChildren,
+                args: [forwardRef(() => BsSwipeDirective)]
+            }], minimumOffset: [{
+                type: Input
+            }], imageIndex: [{
+                type: Input
+            }], imageIndexChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swipe-container.directive.js","sourceRoot":"","sources":["../../../../../../../libs/mintplayer-ng-swiper/src/lib/directives/swipe-container/swipe-container.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { animate, AnimationBuilder, AnimationPlayer, style } from '@angular/animations';\nimport { DOCUMENT } from '@angular/common';\nimport { AfterViewInit, ContentChildren, Directive, ElementRef, EventEmitter, forwardRef, HostBinding, Inject, Input, OnDestroy, Output, QueryList } from '@angular/core';\nimport { BehaviorSubject, combineLatest, filter, map, mergeMap, Observable, Subject, take, takeUntil, takeWhile } from 'rxjs';\nimport { LastTouch } from '../../interfaces/last-touch';\nimport { StartTouch } from '../../interfaces/start-touch';\nimport { BsSwipeDirective } from '../swipe/swipe.directive';\n\n@Directive({\n  selector: '[bsSwipeContainer]',\n  exportAs: 'bsSwipeContainer'\n})\nexport class BsSwipeContainerDirective implements AfterViewInit, OnDestroy {\n\n  constructor(element: ElementRef, private animationBuilder: AnimationBuilder, @Inject(DOCUMENT) document: any) {\n    this.containerElement = element;\n    this.document = <Document>document;\n    this.offset$ = combineLatest([this.startTouch$, this.lastTouch$, this.imageIndex$, this.isViewInited$])\n      .pipe(map(([startTouch, lastTouch, imageIndex, isViewInited]) => {\n        if (!isViewInited) {\n          return (-imageIndex * 100);\n        } else if (!!startTouch && !!lastTouch) {\n          return (-imageIndex * 100 + (lastTouch.position.x - startTouch.position.x) / this.containerElement.nativeElement.clientWidth * 100);\n        } else {\n          return (-imageIndex * 100);\n        }\n      }));\n\n      this.padLeft$ = this.swipes$.pipe(map(swipes => {\n        if (!swipes) {\n          return 0;\n        }\n\n        let count = 0;\n        for (const s of swipes) {\n          if (!s.offside) {\n            break;\n          } else {\n            count++;\n          }\n        }\n        return count;\n      }));\n\n      this.padRight$ = this.swipes$.pipe(map(swipes => {\n        if (!swipes) {\n          return 0;\n        }\n\n        let count = 0;\n        for (const s of swipes.toArray().reverse()) {\n          if (!s.offside) {\n            break;\n          } else {\n            count++;\n          }\n        }\n        return count;\n      }));\n\n    this.offsetLeft$ = combineLatest([this.offset$, this.padLeft$])\n      .pipe(map(([offset, padLeft]) => {\n        return offset - padLeft * 100;\n      }));\n    this.offsetRight$ = combineLatest([this.offset$, this.padLeft$, this.padRight$])\n      .pipe(map(([offset, padLeft, padRight]) => {\n        return -(offset - padLeft * 100) - (padRight - 1) * 100;\n      }));\n    this.offsetLeft$\n      .pipe(takeUntil(this.destroyed$))\n      .subscribe((offsetLeft) => this.offsetLeft = offsetLeft);\n    this.offsetRight$\n      .pipe(takeUntil(this.destroyed$))\n      .subscribe((offsetRight) => this.offsetRight = offsetRight);\n    this.imageIndex$\n      .pipe(takeUntil(this.destroyed$))\n      .subscribe((imageIndex) => this.imageIndexChange.emit(imageIndex));\n\n    this.actualSwipes$ = this.swipes$\n      .pipe(map(swipes => {\n        if (swipes) {\n          return swipes.filter(swipe => !swipe.offside);\n        } else {\n          return [];\n        }\n      }));\n\n    this.slideHeights$ = this.actualSwipes$\n      .pipe(filter(swipes => !!swipes))\n      // .pipe(map(swipes => <QueryList<BsSwipeDirective>>swipes))\n      .pipe(mergeMap(swipes => combineLatest(swipes.map(swipe => swipe.slideHeight$))));\n\n    this.currentSlideHeight$ = combineLatest([this.slideHeights$, this.imageIndex$])\n      .pipe(map(([slideHeights, imageIndex]) => {\n        const maxHeight = Math.max(...slideHeights);\n        const currHeight: number = slideHeights[imageIndex] ?? maxHeight;\n        return maxHeight - (maxHeight - currHeight)/* / 2*/;\n      }));\n  }\n\n  @HostBinding('style.margin-left.%') offsetLeft: number | null = null;\n  @HostBinding('style.margin-right.%') offsetRight: number | null = null;\n  @HostBinding('style.margin-top.%') offsetTop: number | null = null;\n  @HostBinding('style.margin-bottom.%') offsetBottom: number | null = null;\n  @ContentChildren(forwardRef(() => BsSwipeDirective)) set swipes(value: QueryList<BsSwipeDirective>) {\n    setTimeout(() => this.swipes$.next(value));\n  }\n  @Input() minimumOffset = 50;\n\n  //#region ImageIndex\n  public get imageIndex() {\n    return this.imageIndex$.value;\n  }\n  @Input() public set imageIndex(value: number) {\n    this.imageIndex$.next(value);\n  }\n  @Output() imageIndexChange = new EventEmitter<number>();\n  //#endregion\n  \n  actualSwipes$: Observable<BsSwipeDirective[]>;\n  isViewInited$ = new BehaviorSubject<boolean>(false);\n  destroyed$ = new Subject();\n  startTouch$ = new BehaviorSubject<StartTouch | null>(null);\n  lastTouch$ = new BehaviorSubject<LastTouch | null>(null);\n  swipes$ = new BehaviorSubject<QueryList<BsSwipeDirective> | null>(null);\n  imageIndex$ = new BehaviorSubject<number>(0);\n  slideHeights$: Observable<number[]>;\n  currentSlideHeight$: Observable<number>;\n  pendingAnimation?: AnimationPlayer;\n  containerElement: ElementRef<HTMLDivElement>;\n  document: Document;\n\n  offset$: Observable<number>;\n  offsetLeft$: Observable<number>;\n  offsetRight$: Observable<number>;\n  padLeft$: Observable<number>;\n  padRight$: Observable<number>;\n\n  ngAfterViewInit() {\n    this.isViewInited$.next(true);\n  }\n\n  ngOnDestroy() {\n    this.destroyed$.next(true);\n  }\n\n  animateToIndexByDx(dx: number) {\n    combineLatest([this.imageIndex$, this.actualSwipes$]).pipe(take(1))\n      .subscribe(([imageIndex, actualSwipes]) => {\n        const direction = dx > 0 ? 'left' : 'right';\n      \n        let newIndex: number;\n        if (Math.abs(dx) < this.minimumOffset) {\n          newIndex = imageIndex;\n        } else {\n          newIndex = imageIndex + (direction === 'right' ? 1 : -1);\n        }\n  \n        this.animateToIndex(imageIndex, newIndex, dx, actualSwipes?.length ?? 1);\n      });\n  }\n\n  animateToIndex(oldIndex: number, newIndex: number, dx: number, totalSlides: number) {\n    this.pendingAnimation = this.animationBuilder.build([\n      style({ 'margin-left': (-(oldIndex + 1) * this.containerElement.nativeElement.clientWidth + dx) + 'px', 'margin-right': ((oldIndex + 1) * this.containerElement.nativeElement.clientWidth - dx) + 'px' }),\n      animate('500ms ease', style({ 'margin-left': (-(newIndex + 1) * this.containerElement.nativeElement.clientWidth) + 'px', 'margin-right': ((newIndex + 1) * this.containerElement.nativeElement.clientWidth) + 'px' })),\n    ]).create(this.containerElement.nativeElement);\n    this.pendingAnimation.onDone(() => {\n      // Correct the image index\n      if (newIndex === -1) {\n        this.imageIndex$.next(totalSlides - 1);\n      } else if (newIndex === totalSlides) {\n        this.imageIndex$.next(0);\n      } else {\n        this.imageIndex$.next(newIndex);\n      }\n      this.startTouch$.next(null);\n      this.lastTouch$.next(null);\n      this.pendingAnimation?.destroy();\n      this.pendingAnimation = undefined;\n    });\n    this.pendingAnimation.play();\n  }\n\n  onSwipe(dx: number) {\n    this.animateToIndexByDx(dx);\n  }\n\n  previous() {\n    this.pendingAnimation?.finish();\n    combineLatest([this.actualSwipes$, this.imageIndex$]).pipe(take(1)).subscribe(([actualSwipes, imageIndex]) => {\n      setTimeout(() => this.animateToIndex(imageIndex, imageIndex - 1, 0, actualSwipes?.length ?? 1), 20);\n    });\n  }\n\n  next() {\n    this.pendingAnimation?.finish();\n    combineLatest([this.actualSwipes$, this.imageIndex$]).pipe(take(1)).subscribe(([actualSwipes, imageIndex]) => {\n      setTimeout(() => this.animateToIndex(imageIndex, imageIndex + 1, 0, actualSwipes?.length ?? 1), 20);\n    });\n  }\n\n  goto(index: number) {\n    combineLatest([this.actualSwipes$, this.imageIndex$]).pipe(take(1)).subscribe(([actualSwipes, imageIndex]) => {\n      this.pendingAnimation?.finish();\n      setTimeout(() => this.animateToIndex(imageIndex, index, 0, actualSwipes?.length ?? 1), 20);\n    });\n  }\n\n}\n"]}

package/esm2020/lib/interfaces/index.mjs

@@ -0,0 +1,4 @@
+export * from './last-touch';
+export * from './point';
+export * from './start-touch';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctc3dpcGVyL3NyYy9saWIvaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGFzdC10b3VjaCc7XG5leHBvcnQgKiBmcm9tICcuL3BvaW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3RhcnQtdG91Y2gnOyJdfQ==

package/esm2020/lib/interfaces/last-touch.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFzdC10b3VjaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbWludHBsYXllci1uZy1zd2lwZXIvc3JjL2xpYi9pbnRlcmZhY2VzL2xhc3QtdG91Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvaW50IH0gZnJvbSBcIi4vcG9pbnRcIjtcblxuZXhwb3J0IGludGVyZmFjZSBMYXN0VG91Y2gge1xuICAgIHBvc2l0aW9uOiBQb2ludDtcbiAgICBpc1RvdWNoaW5nOiBib29sZWFuO1xufVxuICAiXX0=

package/esm2020/lib/interfaces/point.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctc3dpcGVyL3NyYy9saWIvaW50ZXJmYWNlcy9wb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBQb2ludCB7XG4gICAgeDogbnVtYmVyO1xuICAgIHk6IG51bWJlcjtcbn1cbiAgIl19

package/esm2020/lib/interfaces/start-touch.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQtdG91Y2guanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctc3dpcGVyL3NyYy9saWIvaW50ZXJmYWNlcy9zdGFydC10b3VjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUG9pbnQgfSBmcm9tIFwiLi9wb2ludFwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIFN0YXJ0VG91Y2gge1xuICAgIHBvc2l0aW9uOiBQb2ludDtcbiAgICB0aW1lc3RhbXA6IG51bWJlcjtcbn1cbiAgIl19

package/esm2020/lib/swiper.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ObserversModule } from '@angular/cdk/observers';
+import { BsSwipeDirective } from './directives/swipe/swipe.directive';
+import { BsSwipeContainerDirective } from './directives/swipe-container/swipe-container.directive';
+import * as i0 from "@angular/core";
+export class BsSwiperModule {
+}
+BsSwiperModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwiperModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BsSwiperModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.3", ngImport: i0, type: BsSwiperModule, declarations: [BsSwipeDirective, BsSwipeContainerDirective], imports: [CommonModule, ObserversModule], exports: [BsSwipeDirective, BsSwipeContainerDirective] });
+BsSwiperModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwiperModule, imports: [CommonModule, ObserversModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: BsSwiperModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ObserversModule],
+                    declarations: [BsSwipeDirective, BsSwipeContainerDirective],
+                    exports: [BsSwipeDirective, BsSwipeContainerDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpcGVyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvbWludHBsYXllci1uZy1zd2lwZXIvc3JjL2xpYi9zd2lwZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN6RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUN0RSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQzs7QUFPbkcsTUFBTSxPQUFPLGNBQWM7OzJHQUFkLGNBQWM7NEdBQWQsY0FBYyxpQkFIVixnQkFBZ0IsRUFBRSx5QkFBeUIsYUFEaEQsWUFBWSxFQUFFLGVBQWUsYUFFN0IsZ0JBQWdCLEVBQUUseUJBQXlCOzRHQUUxQyxjQUFjLFlBSmYsWUFBWSxFQUFFLGVBQWU7MkZBSTVCLGNBQWM7a0JBTDFCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGVBQWUsQ0FBQztvQkFDeEMsWUFBWSxFQUFFLENBQUMsZ0JBQWdCLEVBQUUseUJBQXlCLENBQUM7b0JBQzNELE9BQU8sRUFBRSxDQUFDLGdCQUFnQixFQUFFLHlCQUF5QixDQUFDO2lCQUN2RCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgT2JzZXJ2ZXJzTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL29ic2VydmVycyc7XG5pbXBvcnQgeyBCc1N3aXBlRGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmVzL3N3aXBlL3N3aXBlLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBCc1N3aXBlQ29udGFpbmVyRGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmVzL3N3aXBlLWNvbnRhaW5lci9zd2lwZS1jb250YWluZXIuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgT2JzZXJ2ZXJzTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbQnNTd2lwZURpcmVjdGl2ZSwgQnNTd2lwZUNvbnRhaW5lckRpcmVjdGl2ZV0sXG4gIGV4cG9ydHM6IFtCc1N3aXBlRGlyZWN0aXZlLCBCc1N3aXBlQ29udGFpbmVyRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgQnNTd2lwZXJNb2R1bGUge31cbiJdfQ==

package/esm2020/mintplayer-ng-swiper.mjs

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