ngx-sfc-components 0.0.1

package/esm2020/lib/components/carousel/service/carousel/carousel.service.mjs

@@ -0,0 +1,697 @@
+import { Injectable } from '@angular/core';
+import { CommonConstants, isNumeric } from 'ngx-sfc-common';
+import { Subject } from 'rxjs';
+import { CarouselEventType, CarouselProperty, CarouselState } from '../../carousel.enum';
+import { CarouselServiceConstants } from './carousel-service.constants';
+import { Width } from './carousel-service.enum';
+import * as i0 from "@angular/core";
+export class CarouselService {
+    constructor() {
+        this._viewSettingsShipper$ = new Subject();
+        this._initializedCarousel$ = new Subject();
+        this._changeSettingsCarousel$ = new Subject();
+        this._changedSettingsCarousel$ = new Subject();
+        this._translateCarousel$ = new Subject();
+        this._translatedCarousel$ = new Subject();
+        this._resizeCarousel$ = new Subject();
+        this._resizedCarousel$ = new Subject();
+        this._refreshCarousel$ = new Subject();
+        this._refreshedCarousel$ = new Subject();
+        this.carouselDOMModel = {
+            rtl: false,
+            isResponsive: false,
+            isRefreshed: false,
+            isLoaded: false,
+            isLoading: false
+        };
+        this.stageModel = {
+            transform: 'translate3d(0px,0px,0px)',
+            transition: '0s',
+            width: 0,
+            paddingL: 0,
+            paddingR: 0
+        };
+        this._items = [];
+        this._widths = [];
+        this._supress = {};
+        this._current = null;
+        this._clones = [];
+        this._mergers = [];
+        this._speed = null;
+        this._coordinates = [];
+        this._invalidated = {};
+        this._states = {
+            current: {},
+            tags: {
+                initializing: [CarouselState.Busy],
+                animating: [CarouselState.Busy]
+            }
+        };
+        this._pipe = [
+            {
+                filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],
+                run: (cache) => {
+                    cache.current = this._items && this._items[this.relative(this._current || 0)].id;
+                }
+            },
+            {
+                filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],
+                run: (cache) => {
+                    const margin = this.settings.margin || CommonConstants.EMPTY_STRING, grid = !this.settings.autoWidth, rtl = this.settings.rtl, css = {
+                        'margin-left': rtl ? margin : CommonConstants.EMPTY_STRING,
+                        'margin-right': rtl ? CommonConstants.EMPTY_STRING : margin
+                    };
+                    if (!grid) {
+                        this.slidesModel.forEach(slide => {
+                            slide.marginL = css['margin-left'];
+                            slide.marginR = css['margin-right'];
+                        });
+                    }
+                    cache.css = css;
+                }
+            }, {
+                filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],
+                run: (cache) => {
+                    const width = +(this.width() / (this.settings.items || 0)).toFixed(3) - (this.settings.margin || 0), grid = !this.settings.autoWidth, widths = [];
+                    let merge = null, iterator = this._items.length;
+                    cache.items = {
+                        merge: false,
+                        width: width
+                    };
+                    while (iterator--) {
+                        merge = this._mergers[iterator];
+                        merge = this.settings.mergeFit && Math.min(merge, (this.settings.items || 0)) || merge;
+                        cache.items.merge = merge > 1 || cache.items.merge;
+                        widths[iterator] = !grid ? this._items[iterator].width ? this._items[iterator].width : width : width * merge;
+                    }
+                    this._widths = widths;
+                    this.slidesModel.forEach((slide, i) => {
+                        slide.width = this._widths[i];
+                        slide.marginR = cache.css['margin-right'];
+                        slide.marginL = cache.css['margin-left'];
+                    });
+                }
+            }, {
+                filter: [CarouselProperty.Items, CarouselProperty.Settings],
+                run: () => {
+                    const clones = [], items = this._items, settings = this.settings, view = Math.max(settings.items * 2, 4), size = Math.ceil(items.length / 2) * 2;
+                    let append = [], prepend = [], repeat = settings.loop && items.length ? settings.rewind ? view : Math.max(view, size) : 0;
+                    repeat /= 2;
+                    while (repeat--) {
+                        clones.push(this.normalize(clones.length / 2, true));
+                        append.push({ ...this.slidesModel[clones[clones.length - 1]] });
+                        clones.push(this.normalize(items.length - 1 - (clones.length - 1) / 2, true));
+                        prepend.unshift({ ...this.slidesModel[clones[clones.length - 1]] });
+                    }
+                    this._clones = clones;
+                    append = append.map(slide => {
+                        slide.id = `${CarouselServiceConstants.CLONE_ID_PREFIX}${slide.id}`;
+                        slide.isActive = false;
+                        slide.isCloned = true;
+                        return slide;
+                    });
+                    prepend = prepend.map(slide => {
+                        slide.id = `${CarouselServiceConstants.CLONE_ID_PREFIX}${slide.id}`;
+                        slide.isActive = false;
+                        slide.isCloned = true;
+                        return slide;
+                    });
+                    this.slidesModel = prepend.concat(this.slidesModel).concat(append);
+                }
+            }, {
+                filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],
+                run: () => {
+                    const rtl = this.settings.rtl ? 1 : -1, size = this._clones.length + this._items.length, coordinates = [];
+                    let iterator = -1, previous = 0, current = 0;
+                    while (++iterator < size) {
+                        previous = coordinates[iterator - 1] || 0;
+                        current = this._widths[this.relative(iterator)] + this.settings.margin;
+                        coordinates.push(previous + current * rtl);
+                    }
+                    this._coordinates = coordinates;
+                }
+            }, {
+                filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],
+                run: () => {
+                    const padding = this.settings.stagePadding || 0, coordinates = this._coordinates, css = {
+                        'width': Math.ceil(Math.abs(coordinates[coordinates.length - 1])) + padding * 2,
+                        'padding-left': padding || '',
+                        'padding-right': padding || ''
+                    };
+                    this.stageModel.width = css.width;
+                    this.stageModel.paddingR = css['padding-right'];
+                }
+            }, {
+                filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],
+                run: (cache) => {
+                    let current = cache.current ? this.slidesModel.findIndex(slide => slide.id === cache.current) : 0;
+                    current = Math.max(this.minimum(), Math.min(this.maximum(), current));
+                    this.reset(current);
+                }
+            }, {
+                filter: [CarouselProperty.Position],
+                run: () => {
+                    this.animate(this.coordinates(this._current));
+                }
+            }, {
+                filter: [CarouselProperty.Width, CarouselProperty.Position, CarouselProperty.Items, CarouselProperty.Settings],
+                run: () => {
+                    const rtl = this.settings.rtl ? 1 : -1, padding = (this.settings.stagePadding || 0) * 2, matches = [];
+                    let begin, end, inner, outer, i, n;
+                    begin = this.coordinates(this.current());
+                    if (typeof begin === 'number') {
+                        begin += padding;
+                    }
+                    else {
+                        begin = 0;
+                    }
+                    end = begin + this.width() * rtl;
+                    if (rtl === -1 && this.settings.center) {
+                        const result = this._coordinates.filter(element => {
+                            return (this.settings.items || 0) % 2 === 1 ? element >= begin : element > begin;
+                        });
+                        begin = result.length ? result[result.length - 1] : begin;
+                    }
+                    for (i = 0, n = this._coordinates.length; i < n; i++) {
+                        inner = Math.ceil(this._coordinates[i - 1] || 0);
+                        outer = Math.ceil(Math.abs(this._coordinates[i]) + padding * rtl);
+                        if ((this.op(inner, '<=', begin) && (this.op(inner, '>', end)))
+                            || (this.op(outer, '<', begin) && this.op(outer, '>', end))) {
+                            matches.push(i);
+                        }
+                    }
+                    this.slidesModel.forEach(slide => {
+                        slide.isActive = false;
+                        return slide;
+                    });
+                    matches.forEach(item => {
+                        this.slidesModel[item].isActive = true;
+                    });
+                    if (this.settings.center) {
+                        this.slidesModel.forEach(slide => {
+                            slide.isCentered = false;
+                            return slide;
+                        });
+                        const currentValue = this.current();
+                        if (currentValue)
+                            this.slidesModel[currentValue].isCentered = true;
+                    }
+                }
+            }
+        ];
+        this.settings = {
+            items: 0
+        };
+        this.options = {};
+    }
+    get viewCurrrentSettings() {
+        return this._viewSettingsShipper$.asObservable();
+    }
+    get initializedState() {
+        return this._initializedCarousel$.asObservable();
+    }
+    get changeState() {
+        return this._changeSettingsCarousel$.asObservable();
+    }
+    get changedState() {
+        return this._changedSettingsCarousel$.asObservable();
+    }
+    get translateState() {
+        return this._translateCarousel$.asObservable();
+    }
+    get translatedState() {
+        return this._translatedCarousel$.asObservable();
+    }
+    get resizeState() {
+        return this._resizeCarousel$.asObservable();
+    }
+    get resizedState() {
+        return this._resizedCarousel$.asObservable();
+    }
+    get refreshState() {
+        return this._refreshCarousel$.asObservable();
+    }
+    get refreshedState() {
+        return this._refreshedCarousel$.asObservable();
+    }
+    setup(carouselWidth, slides, options) {
+        this.setCarouselWidth(carouselWidth);
+        this.setItems(slides);
+        this.defineSlidesData();
+        this.setOptions(options);
+        this.settings = { ...this.options };
+        this.setOptionsForViewport();
+        this.trigger(CarouselEventType.Change, { property: { name: CarouselProperty.Settings, value: this.settings } });
+        this.invalidate(CarouselProperty.Settings);
+        this.trigger(CarouselEventType.Changed, { property: { name: CarouselProperty.Settings, value: this.settings } });
+    }
+    initialize(slides) {
+        this.enter(CarouselEventType.Initializing);
+        this.carouselDOMModel.rtl = this.settings.rtl || false;
+        if (this._mergers.length) {
+            this._mergers = [];
+        }
+        slides.forEach(item => {
+            const mergeN = this.settings.merge ? item.dataMerge : 1;
+            this._mergers.push(mergeN);
+        });
+        this._clones = [];
+        this.reset(isNumeric(this.settings.startPosition) ? +(this.settings.startPosition || 0) : 0);
+        this.invalidate(CarouselProperty.Items);
+        this.refresh();
+        this.carouselDOMModel.isLoaded = true;
+        this.sendChanges();
+        this.leave(CarouselEventType.Initializing);
+        this.trigger(CarouselEventType.Initialized);
+    }
+    ;
+    sendChanges() {
+        this._viewSettingsShipper$.next({
+            carouselDOMModel: this.carouselDOMModel,
+            stageModel: this.stageModel,
+            slidesModel: this.slidesModel,
+            navigationModel: this.navigationModel,
+            navigationDotsModel: this.navigationDotsModel
+        });
+    }
+    onResize(curWidth) {
+        if (this._items.length) {
+            this.setCarouselWidth(curWidth);
+            this.enter(CarouselEventType.Resizing);
+            this.trigger(CarouselEventType.Resize);
+            this.invalidate(CarouselProperty.Width);
+            this.refresh();
+            this.leave(CarouselEventType.Resizing);
+            this.trigger(CarouselEventType.Resized);
+        }
+    }
+    is(state) {
+        return this._states.current[state] && this._states.current[state] > 0;
+    }
+    ;
+    current(position) {
+        if (position === undefined) {
+            return this._current;
+        }
+        if (this._items.length === 0) {
+            return undefined;
+        }
+        position = this.normalize(position);
+        if (this._current !== position) {
+            this.trigger(CarouselEventType.Change, { property: { name: CarouselProperty.Position, value: position } });
+            this._current = position;
+            this.invalidate(CarouselProperty.Position);
+            this.trigger(CarouselEventType.Changed, { property: { name: CarouselProperty.Position, value: this._current } });
+        }
+        return this._current;
+    }
+    relative(position) {
+        position -= this._clones.length / 2;
+        return this.normalize(position, true);
+    }
+    maximum(relative = false) {
+        const settings = this.settings;
+        let maximum = this._coordinates.length, iterator, reciprocalItemsWidth, elementWidth;
+        if (settings.loop) {
+            maximum = this._clones.length / 2 + this._items.length - 1;
+        }
+        else if (settings.autoWidth || settings.merge) {
+            iterator = this._items.length;
+            reciprocalItemsWidth = this.slidesModel[--iterator].width;
+            elementWidth = this._width;
+            while (iterator--) {
+                reciprocalItemsWidth += +this.slidesModel[iterator].width + (this.settings.margin || 0).toString();
+                if (reciprocalItemsWidth > elementWidth) {
+                    break;
+                }
+            }
+            maximum = iterator + 1;
+        }
+        else if (settings.center) {
+            maximum = this._items.length - 1;
+        }
+        else {
+            maximum = this._items.length - (settings.items || 0);
+        }
+        if (relative) {
+            maximum -= this._clones.length / 2;
+        }
+        return Math.max(maximum, 0);
+    }
+    minimum(relative = false) {
+        return relative ? 0 : this._clones.length / 2;
+    }
+    items(position) {
+        if (position === undefined) {
+            return this._items.slice();
+        }
+        position = this.normalize(position, true);
+        return [this._items[position]];
+    }
+    mergers(position) {
+        if (position === undefined) {
+            return this._mergers.slice();
+        }
+        position = this.normalize(position, true);
+        return this._mergers[position];
+    }
+    clones(position) {
+        const odd = this._clones.length / 2, even = odd + this._items.length, map = (index) => index % 2 === 0 ? even + index / 2 : odd - (index + 1) / 2;
+        if (position === undefined) {
+            return this._clones.map((v, i) => map(i));
+        }
+        return this._clones.map((v, i) => v === position ? map(i) : null).filter(item => item);
+    }
+    speed(speed) {
+        if (speed !== undefined) {
+            this._speed = speed;
+        }
+        return this._speed || 0;
+    }
+    coordinates(position) {
+        let multiplier = 1, newPosition = (position || 0) - 1, coordinate, result;
+        if (position === undefined) {
+            result = this._coordinates.map((_, index) => {
+                return this.coordinates(index);
+            });
+            return result;
+        }
+        if (this.settings.center) {
+            if (this.settings.rtl) {
+                multiplier = -1;
+                newPosition = (position || 0) + 1;
+            }
+            coordinate = this._coordinates[(position || 0)];
+            coordinate += (this.width() - coordinate + (this._coordinates[newPosition] || 0)) / 2 * multiplier;
+        }
+        else {
+            coordinate = this._coordinates[newPosition] || 0;
+        }
+        coordinate = Math.ceil(coordinate);
+        return coordinate;
+    }
+    to(position, speed) {
+        let current = this.current(), revert = null, distance = position - this.relative(current || 0), maximum = this.maximum(), delayForLoop = 0;
+        const direction = +(distance > 0) - +(distance < 0), items = this._items.length, minimum = this.minimum();
+        if (this.settings.loop) {
+            if (!this.settings.rewind && Math.abs(distance) > items / 2) {
+                distance += direction * -1 * items;
+            }
+            position = (current || 0) + distance;
+            revert = ((position - minimum) % items + items) % items + minimum;
+            if (revert !== position && revert - distance <= maximum && revert - distance > 0) {
+                current = revert - distance;
+                position = revert;
+                delayForLoop = 30;
+                this.reset(current);
+                this.sendChanges();
+            }
+        }
+        else if (this.settings.rewind) {
+            maximum += 1;
+            position = (position % maximum + maximum) % maximum;
+        }
+        else {
+            position = Math.max(minimum, Math.min(maximum, position));
+        }
+        setTimeout(() => {
+            this.speed(this.duration(current || 0, position, speed));
+            this.current(position);
+            this.update();
+        }, delayForLoop);
+    }
+    next(speed) {
+        speed = speed || false;
+        this.to(this.relative(this.current() || 0) + 1, speed);
+    }
+    previous(speed) {
+        speed = speed || false;
+        this.to(this.relative(this.current() || 0) - 1, speed);
+    }
+    onTransitionEnd(event) {
+        if (!event) {
+            this.leave(CarouselEventType.Animating);
+            this.trigger(CarouselEventType.Translated);
+        }
+    }
+    setCurrentSlideClasses(slide) {
+        const currentClasses = {
+            'active': slide.isActive || false,
+            'center': slide.isCentered || false,
+            'cloned': slide.isCloned || false,
+            'animated': slide.isAnimated || false,
+            'animated-in': slide.isDefAnimatedIn || false,
+            'animated-out': slide.isDefAnimatedOut || false
+        };
+        if (this.settings.animateIn) {
+            currentClasses[this.settings.animateIn] = slide.isCustomAnimatedIn || false;
+        }
+        if (this.settings.animateOut) {
+            currentClasses[this.settings.animateOut] = slide.isCustomAnimatedOut || false;
+        }
+        return currentClasses;
+    }
+    enter(name) {
+        [name].concat(this._states.tags[name] || []).forEach((stateName) => {
+            if (this._states.current[stateName] === undefined) {
+                this._states.current[stateName] = 0;
+            }
+            this._states.current[stateName]++;
+        });
+    }
+    ;
+    leave(name) {
+        [name].concat(this._states.tags[name] || []).forEach((stateName) => {
+            if (this._states.current[stateName] === 0 || !!this._states.current[stateName]) {
+                this._states.current[stateName]--;
+            }
+        });
+    }
+    ;
+    setOptions(options) {
+        this.options = { ...CarouselServiceConstants.DEFAULT_OPTIONS, ...options };
+    }
+    validateItems(items, skip_validateItems) {
+        let result = items;
+        if (items > this._items.length && !skip_validateItems) {
+            result = this._items.length;
+        }
+        return result;
+    }
+    setCarouselWidth(width) {
+        this._width = width;
+    }
+    setOptionsForViewport() {
+        const viewport = this._width, overwrites = this.options.responsive || {};
+        let match = -1;
+        if (!Object.keys(overwrites).length) {
+            return;
+        }
+        if (!viewport) {
+            this.settings.items = 1;
+            return;
+        }
+        for (const key in overwrites) {
+            if (overwrites.hasOwnProperty(key)) {
+                if (+key <= viewport && +key > match) {
+                    match = Number(key);
+                }
+            }
+        }
+        this.settings = { ...this.options, ...overwrites[match], items: (overwrites[match] && overwrites[match].items) ? this.validateItems(overwrites[match].items || 0, this.options.skip_validateItems || false) : this.options.items };
+        delete this.settings.responsive;
+        this.carouselDOMModel.isResponsive = true;
+        const mergers = [];
+        this._items.forEach(item => {
+            const mergeN = this.settings.merge ? item.dataMerge : 1;
+            mergers.push(mergeN);
+        });
+        this._mergers = mergers;
+        this.invalidate(CarouselProperty.Settings);
+    }
+    optionsLogic() {
+        if (this.settings.autoWidth) {
+            this.settings.stagePadding = 0;
+            this.settings.merge = false;
+        }
+    }
+    update() {
+        let i = 0;
+        const n = this._pipe.length, filter = (item) => this._invalidated[item], cache = {};
+        while (i < n) {
+            const filteredPipe = this._pipe[i].filter.filter(filter);
+            if (this._invalidated.all || filteredPipe.length > 0) {
+                this._pipe[i].run(cache);
+            }
+            i++;
+        }
+        this.slidesModel.forEach(slide => slide.classes = this.setCurrentSlideClasses(slide));
+        this.sendChanges();
+        this._invalidated = {};
+        if (!this.is('valid')) {
+            this.enter('valid');
+        }
+    }
+    width(dimension) {
+        dimension = dimension || Width.Default;
+        switch (dimension) {
+            case Width.Inner:
+            case Width.Outer:
+                return this._width;
+            default:
+                return this._width - (this.settings.stagePadding || 0) * 2 + (this.settings.margin || 0);
+        }
+    }
+    refresh() {
+        this.enter(CarouselEventType.Refreshing);
+        this.trigger(CarouselEventType.Refresh);
+        this.defineSlidesData();
+        this.setOptionsForViewport();
+        this.optionsLogic();
+        this.update();
+        this.leave(CarouselEventType.Refreshing);
+        this.trigger(CarouselEventType.Refreshed);
+    }
+    animate(coordinate) {
+        const animate = this.speed() > 0;
+        if (this.is(CarouselEventType.Animating)) {
+            this.onTransitionEnd();
+        }
+        if (animate) {
+            this.enter(CarouselEventType.Animating);
+            this.trigger(CarouselEventType.Translate);
+        }
+        this.stageModel.transform = 'translate3d(' + coordinate + 'px,0px,0px)';
+        this.stageModel.transition = (this.speed() / 1000) + 's' + (this.settings.slideTransition ? ' ' + this.settings.slideTransition : '');
+    }
+    invalidate(part) {
+        if (typeof part === 'string') {
+            this._invalidated[part] = true;
+            if (this.is('valid')) {
+                this.leave('valid');
+            }
+        }
+        return Object.keys(this._invalidated);
+    }
+    ;
+    reset(position) {
+        position = this.normalize(position);
+        if (position === undefined) {
+            return;
+        }
+        this._speed = 0;
+        this._current = position;
+        this.suppress([CarouselEventType.Translate, CarouselEventType.Translated]);
+        this.animate(this.coordinates(position));
+        this.release([CarouselEventType.Translate, CarouselEventType.Translated]);
+    }
+    normalize(position, relative) {
+        const n = this._items.length, m = relative ? 0 : this._clones.length;
+        if (!isNumeric(position) || n < 1) {
+            position = 0;
+        }
+        else if (position < 0 || position >= n + m) {
+            position = ((position - m / 2) % n + n) % n + m / 2;
+        }
+        return position;
+    }
+    duration(from, to, factor) {
+        if (factor === 0) {
+            return 0;
+        }
+        return Math.min(Math.max(Math.abs(to - from), 1), 6) * Math.abs((+factor));
+    }
+    setItems(content) {
+        this._items = content;
+    }
+    defineSlidesData() {
+        let loadMap;
+        if (this.slidesModel && this.slidesModel.length) {
+            loadMap = new Map();
+            this.slidesModel.forEach(item => {
+                if (item.load) {
+                    loadMap.set(item.id, item.load);
+                }
+            });
+        }
+        this.slidesModel = this._items.map(slide => {
+            return {
+                id: `${slide.id}`,
+                isActive: false,
+                tplRef: slide.tplRef,
+                dataMerge: slide.dataMerge,
+                width: 0,
+                isCloned: false,
+                load: loadMap ? loadMap.get(slide.id) : false,
+                classes: {}
+            };
+        });
+    }
+    op(a, o, b) {
+        const rtl = this.settings.rtl;
+        switch (o) {
+            case '<':
+                return rtl ? a > b : a < b;
+            case '>':
+                return rtl ? a < b : a > b;
+            case '>=':
+                return rtl ? a <= b : a >= b;
+            case '<=':
+                return rtl ? a >= b : a <= b;
+            default:
+                return false;
+        }
+    }
+    trigger(name, data) {
+        switch (name) {
+            case CarouselEventType.Initialized:
+                this._initializedCarousel$.next(name);
+                break;
+            case CarouselEventType.Change:
+                this._changeSettingsCarousel$.next(data);
+                break;
+            case CarouselEventType.Changed:
+                this._changedSettingsCarousel$.next(data);
+                break;
+            case CarouselEventType.Resize:
+                this._resizeCarousel$.next(name);
+                break;
+            case CarouselEventType.Resized:
+                this._resizedCarousel$.next(name);
+                break;
+            case CarouselEventType.Refresh:
+                this._refreshCarousel$.next(name);
+                break;
+            case CarouselEventType.Refreshed:
+                this._refreshedCarousel$.next(name);
+                break;
+            case CarouselEventType.Translate:
+                this._translateCarousel$.next(name);
+                break;
+            case CarouselEventType.Translated:
+                this._translatedCarousel$.next(name);
+                break;
+            default:
+                break;
+        }
+    }
+    suppress(events) {
+        events.forEach(event => {
+            this._supress[event] = true;
+        });
+    }
+    release(events) {
+        events.forEach(event => {
+            delete this._supress[event];
+        });
+    }
+}
+CarouselService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CarouselService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: CarouselService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"carousel.service.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-sfc-components/src/lib/components/carousel/service/carousel/carousel.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { CommonConstants, isNumeric } from 'ngx-sfc-common';\r\nimport { Observable, Subject } from 'rxjs';\r\nimport { CarouselEventType, CarouselProperty, CarouselState } from '../../carousel.enum';\r\nimport { CarouselSlideDirective } from '../../directive/carousel-slide.directive';\r\nimport { CarouselDOMModel } from '../../models/dom.model';\r\nimport { CarouselNavigationDotsModel, CarouselNavigationModel } from '../../models/navigation.model';\r\nimport { CarouselOptionsModel } from '../../models/options.model';\r\nimport { CarouselSlideModel } from '../../models/slide.model';\r\nimport { CarouselStageModel } from '../../parts/stage/carousel-stage.model';\r\nimport { CarouselServiceConstants } from './carousel-service.constants';\r\nimport { Width } from './carousel-service.enum';\r\nimport { CarouselCurrentData, States } from './carousel-service.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CarouselService {\r\n\r\n  private _viewSettingsShipper$ = new Subject<CarouselCurrentData>();\r\n\r\n  private _initializedCarousel$ = new Subject<string>();\r\n\r\n  private _changeSettingsCarousel$ = new Subject<any>();\r\n\r\n  private _changedSettingsCarousel$ = new Subject<any>();\r\n\r\n  private _translateCarousel$ = new Subject<string>();\r\n\r\n  private _translatedCarousel$ = new Subject<string>();\r\n\r\n  private _resizeCarousel$ = new Subject<string>();\r\n\r\n  private _resizedCarousel$ = new Subject<string>();\r\n\r\n  private _refreshCarousel$ = new Subject<string>();\r\n\r\n  private _refreshedCarousel$ = new Subject<string>();\r\n\r\n  private carouselDOMModel: CarouselDOMModel = {\r\n    rtl: false,\r\n    isResponsive: false,\r\n    isRefreshed: false,\r\n    isLoaded: false,\r\n    isLoading: false\r\n  };\r\n\r\n  private stageModel: CarouselStageModel = {\r\n    transform: 'translate3d(0px,0px,0px)',\r\n    transition: '0s',\r\n    width: 0,\r\n    paddingL: 0,\r\n    paddingR: 0\r\n  };\r\n\r\n  private _width!: number;\r\n\r\n  private _items: CarouselSlideDirective[] = [];\r\n\r\n  private _widths: any[] = [];\r\n\r\n  private _supress: any = {};\r\n\r\n  private _current: number | null = null;\r\n\r\n  private _clones: any[] = [];\r\n\r\n  private _mergers: any[] = [];\r\n\r\n  private _speed: number | null = null;\r\n\r\n  private _coordinates: number[] = [];\r\n\r\n  private _invalidated: any = {};\r\n\r\n  private _states: States = {\r\n    current: {},\r\n    tags: {\r\n      initializing: [CarouselState.Busy],\r\n      animating: [CarouselState.Busy]\r\n    }\r\n  };\r\n\r\n  private _pipe: any[] = [\r\n    {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: (cache: any) => {\r\n        cache.current = this._items && this._items[this.relative(this._current || 0)].id;\r\n      }\r\n    },\r\n    {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: (cache: any) => {\r\n        const margin = this.settings.margin || CommonConstants.EMPTY_STRING,\r\n          grid = !this.settings.autoWidth,\r\n          rtl = this.settings.rtl,\r\n          css = {\r\n            'margin-left': rtl ? margin : CommonConstants.EMPTY_STRING,\r\n            'margin-right': rtl ? CommonConstants.EMPTY_STRING : margin\r\n          };\r\n\r\n        if (!grid) {\r\n          this.slidesModel.forEach(slide => {\r\n            slide.marginL = css['margin-left'];\r\n            slide.marginR = css['margin-right'];\r\n          });\r\n        }\r\n\r\n        cache.css = css;\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: (cache: any) => {\r\n        const width: any = +(this.width() / (this.settings.items || 0)).toFixed(3) - (this.settings.margin || 0),\r\n          grid = !this.settings.autoWidth,\r\n          widths = [];\r\n        let merge = null,\r\n          iterator = this._items.length;\r\n\r\n        cache.items = {\r\n          merge: false,\r\n          width: width\r\n        };\r\n\r\n        while (iterator--) {\r\n          merge = this._mergers[iterator];\r\n          merge = this.settings.mergeFit && Math.min(merge, (this.settings.items || 0)) || merge;\r\n          cache.items.merge = merge > 1 || cache.items.merge;\r\n\r\n          widths[iterator] = !grid ? this._items[iterator].width ? this._items[iterator].width : width : width * merge;\r\n        }\r\n\r\n        this._widths = widths;\r\n\r\n        this.slidesModel.forEach((slide, i) => {\r\n          slide.width = this._widths[i];\r\n          slide.marginR = cache.css['margin-right'];\r\n          slide.marginL = cache.css['margin-left'];\r\n        });\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: () => {\r\n        const clones: any[] = [],\r\n          items: CarouselSlideDirective[] = this._items,\r\n          settings: any = this.settings,\r\n          view = Math.max(settings.items * 2, 4),\r\n          size = Math.ceil(items.length / 2) * 2;\r\n        let append: any[] = [],\r\n          prepend: any[] = [],\r\n          repeat = settings.loop && items.length ? settings.rewind ? view : Math.max(view, size) : 0;\r\n\r\n        repeat /= 2;\r\n\r\n        while (repeat--) {\r\n          clones.push(this.normalize(clones.length / 2, true));\r\n          append.push({ ...this.slidesModel[clones[clones.length - 1]] });\r\n          clones.push(this.normalize(items.length - 1 - (clones.length - 1) / 2, true));\r\n          prepend.unshift({ ...this.slidesModel[clones[clones.length - 1]] });\r\n        }\r\n\r\n        this._clones = clones;\r\n\r\n        append = append.map(slide => {\r\n          slide.id = `${CarouselServiceConstants.CLONE_ID_PREFIX}${slide.id}`;\r\n          slide.isActive = false;\r\n          slide.isCloned = true;\r\n          return slide;\r\n        });\r\n\r\n        prepend = prepend.map(slide => {\r\n          slide.id = `${CarouselServiceConstants.CLONE_ID_PREFIX}${slide.id}`;\r\n          slide.isActive = false;\r\n          slide.isCloned = true;\r\n          return slide;\r\n        });\r\n\r\n        this.slidesModel = prepend.concat(this.slidesModel).concat(append);\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: () => {\r\n        const rtl = this.settings.rtl ? 1 : -1,\r\n          size = this._clones.length + this._items.length,\r\n          coordinates = [];\r\n        let iterator = -1,\r\n          previous = 0,\r\n          current = 0;\r\n\r\n        while (++iterator < size) {\r\n          previous = coordinates[iterator - 1] || 0;\r\n          current = this._widths[this.relative(iterator)] + this.settings.margin;\r\n          coordinates.push(previous + current * rtl);\r\n        }\r\n\r\n        this._coordinates = coordinates;\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: () => {\r\n        const padding = this.settings.stagePadding || 0,\r\n          coordinates = this._coordinates,\r\n          css = {\r\n            'width': Math.ceil(Math.abs(coordinates[coordinates.length - 1])) + padding * 2,\r\n            'padding-left': padding || '',\r\n            'padding-right': padding || ''\r\n          };\r\n\r\n        this.stageModel.width = css.width;\r\n        this.stageModel.paddingR = css['padding-right'];\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: (cache: any) => {\r\n        let current = cache.current ? this.slidesModel.findIndex(slide => slide.id === cache.current) : 0;\r\n        current = Math.max(this.minimum(), Math.min(this.maximum(), current));\r\n        this.reset(current);\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Position],\r\n      run: () => {\r\n        this.animate(this.coordinates(this._current));\r\n      }\r\n    }, {\r\n      filter: [CarouselProperty.Width, CarouselProperty.Position, CarouselProperty.Items, CarouselProperty.Settings],\r\n      run: () => {\r\n        const rtl = this.settings.rtl ? 1 : -1,\r\n          padding = (this.settings.stagePadding || 0) * 2,\r\n          matches = [];\r\n        let begin: any, end, inner, outer, i, n;\r\n\r\n        begin = this.coordinates(this.current());\r\n        if (typeof begin === 'number') {\r\n          begin += padding;\r\n        } else {\r\n          begin = 0;\r\n        }\r\n\r\n        end = begin + this.width() * rtl;\r\n\r\n        if (rtl === -1 && this.settings.center) {\r\n          const result = this._coordinates.filter(element => {\r\n            return (this.settings.items || 0) % 2 === 1 ? element >= begin : element > begin;\r\n          });\r\n          begin = result.length ? result[result.length - 1] : begin;\r\n        }\r\n\r\n        for (i = 0, n = this._coordinates.length; i < n; i++) {\r\n          inner = Math.ceil(this._coordinates[i - 1] || 0);\r\n          outer = Math.ceil(Math.abs(this._coordinates[i]) + padding * rtl);\r\n\r\n          if ((this.op(inner, '<=', begin) && (this.op(inner, '>', end)))\r\n            || (this.op(outer, '<', begin) && this.op(outer, '>', end))) {\r\n            matches.push(i);\r\n          }\r\n        }\r\n\r\n        this.slidesModel.forEach(slide => {\r\n          slide.isActive = false;\r\n          return slide;\r\n        });\r\n        matches.forEach(item => {\r\n          this.slidesModel[item].isActive = true;\r\n        });\r\n\r\n        if (this.settings.center) {\r\n          this.slidesModel.forEach(slide => {\r\n            slide.isCentered = false;\r\n            return slide;\r\n          });\r\n          const currentValue = this.current();\r\n          if (currentValue)\r\n            this.slidesModel[currentValue].isCentered = true;\r\n        }\r\n      }\r\n    }\r\n  ];\r\n\r\n  settings: CarouselOptionsModel = {\r\n    items: 0\r\n  };\r\n\r\n  slidesModel!: CarouselSlideModel[];\r\n\r\n  navigationModel!: CarouselNavigationModel;\r\n\r\n  navigationDotsModel!: CarouselNavigationDotsModel;\r\n\r\n  options: CarouselOptionsModel = {};\r\n\r\n  get viewCurrrentSettings(): Observable<CarouselCurrentData> {\r\n    return this._viewSettingsShipper$.asObservable();\r\n  }\r\n\r\n  get initializedState(): Observable<string> {\r\n    return this._initializedCarousel$.asObservable()\r\n  }\r\n\r\n  get changeState(): Observable<any> {\r\n    return this._changeSettingsCarousel$.asObservable();\r\n  }\r\n\r\n  get changedState(): Observable<any> {\r\n    return this._changedSettingsCarousel$.asObservable();\r\n  }\r\n\r\n  get translateState(): Observable<string> {\r\n    return this._translateCarousel$.asObservable();\r\n  }\r\n\r\n  get translatedState(): Observable<string> {\r\n    return this._translatedCarousel$.asObservable();\r\n  }\r\n\r\n  get resizeState(): Observable<string> {\r\n    return this._resizeCarousel$.asObservable();\r\n  }\r\n\r\n  get resizedState(): Observable<string> {\r\n    return this._resizedCarousel$.asObservable();\r\n  }\r\n\r\n  get refreshState(): Observable<string> {\r\n    return this._refreshCarousel$.asObservable();\r\n  }\r\n\r\n  get refreshedState(): Observable<string> {\r\n    return this._refreshedCarousel$.asObservable();\r\n  }\r\n\r\n  setup(carouselWidth: number, slides: CarouselSlideDirective[], options: CarouselOptionsModel) {\r\n    this.setCarouselWidth(carouselWidth);\r\n    this.setItems(slides);\r\n    this.defineSlidesData();\r\n    this.setOptions(options);\r\n\r\n    this.settings = { ...this.options };\r\n\r\n    this.setOptionsForViewport();\r\n\r\n    this.trigger(CarouselEventType.Change, { property: { name: CarouselProperty.Settings, value: this.settings } });\r\n    this.invalidate(CarouselProperty.Settings);\r\n    this.trigger(CarouselEventType.Changed, { property: { name: CarouselProperty.Settings, value: this.settings } });\r\n  }\r\n\r\n  initialize(slides: CarouselSlideDirective[]) {\r\n    this.enter(CarouselEventType.Initializing);\r\n\r\n    this.carouselDOMModel.rtl = this.settings.rtl || false;\r\n\r\n    if (this._mergers.length) {\r\n      this._mergers = [];\r\n    }\r\n\r\n    slides.forEach(item => {\r\n      const mergeN: number = this.settings.merge ? item.dataMerge : 1;\r\n      this._mergers.push(mergeN);\r\n    });\r\n    this._clones = [];\r\n\r\n    this.reset(isNumeric(this.settings.startPosition) ? +(this.settings.startPosition || 0) : 0);\r\n\r\n    this.invalidate(CarouselProperty.Items);\r\n    this.refresh();\r\n\r\n    this.carouselDOMModel.isLoaded = true;\r\n\r\n    this.sendChanges();\r\n\r\n    this.leave(CarouselEventType.Initializing);\r\n    this.trigger(CarouselEventType.Initialized);\r\n  };\r\n\r\n  sendChanges() {\r\n    this._viewSettingsShipper$.next({\r\n      carouselDOMModel: this.carouselDOMModel,\r\n      stageModel: this.stageModel,\r\n      slidesModel: this.slidesModel,\r\n      navigationModel: this.navigationModel,\r\n      navigationDotsModel: this.navigationDotsModel\r\n    });\r\n  }\r\n\r\n  onResize(curWidth: number) {\r\n    if (this._items.length) {\r\n      this.setCarouselWidth(curWidth);\r\n      this.enter(CarouselEventType.Resizing);\r\n      this.trigger(CarouselEventType.Resize);\r\n      this.invalidate(CarouselProperty.Width);\r\n      this.refresh();\r\n      this.leave(CarouselEventType.Resizing);\r\n      this.trigger(CarouselEventType.Resized);\r\n    }\r\n  }\r\n\r\n  is(state: string): boolean {\r\n    return (this._states.current as any)[state] && (this._states.current as any)[state] > 0;\r\n  };\r\n\r\n  current(position?: number): number | undefined {\r\n    if (position === undefined) {\r\n      return this._current as number;\r\n    }\r\n\r\n    if (this._items.length === 0) {\r\n      return undefined;\r\n    }\r\n\r\n    position = this.normalize(position);\r\n\r\n    if (this._current !== position) {\r\n      this.trigger(CarouselEventType.Change, { property: { name: CarouselProperty.Position, value: position } });\r\n\r\n      this._current = position;\r\n\r\n      this.invalidate(CarouselProperty.Position);\r\n      this.trigger(CarouselEventType.Changed, { property: { name: CarouselProperty.Position, value: this._current } });\r\n    }\r\n\r\n    return this._current;\r\n  }\r\n\r\n  relative(position: number): number {\r\n    position -= this._clones.length / 2;\r\n    return this.normalize(position, true);\r\n  }\r\n\r\n  maximum(relative: boolean = false): number {\r\n    const settings = this.settings;\r\n    let maximum = this._coordinates.length,\r\n      iterator,\r\n      reciprocalItemsWidth,\r\n      elementWidth;\r\n\r\n    if (settings.loop) {\r\n      maximum = this._clones.length / 2 + this._items.length - 1;\r\n    } else if (settings.autoWidth || settings.merge) {\r\n      iterator = this._items.length;\r\n      reciprocalItemsWidth = this.slidesModel[--iterator].width;\r\n      elementWidth = this._width;\r\n      while (iterator--) {\r\n        reciprocalItemsWidth += +(this.slidesModel[iterator].width as string) + (this.settings.margin || 0).toString();\r\n        if ((reciprocalItemsWidth as number) > elementWidth) {\r\n          break;\r\n        }\r\n      }\r\n      maximum = iterator + 1;\r\n    } else if (settings.center) {\r\n      maximum = this._items.length - 1;\r\n    } else {\r\n      maximum = this._items.length - (settings.items || 0);\r\n    }\r\n\r\n    if (relative) {\r\n      maximum -= this._clones.length / 2;\r\n    }\r\n\r\n    return Math.max(maximum, 0);\r\n  }\r\n\r\n  minimum(relative: boolean = false): number {\r\n    return relative ? 0 : this._clones.length / 2;\r\n  }\r\n\r\n  items(position?: number): CarouselSlideDirective[] {\r\n    if (position === undefined) {\r\n      return this._items.slice();\r\n    }\r\n\r\n    position = this.normalize(position, true);\r\n    return [this._items[position]];\r\n  }\r\n\r\n  mergers(position: number): number | number[] {\r\n    if (position === undefined) {\r\n      return this._mergers.slice();\r\n    }\r\n\r\n    position = this.normalize(position, true);\r\n    return this._mergers[position];\r\n  }\r\n\r\n  clones(position?: number): number[] {\r\n    const odd = this._clones.length / 2,\r\n      even = odd + this._items.length,\r\n      map = (index: number) => index % 2 === 0 ? even + index / 2 : odd - (index + 1) / 2;\r\n\r\n    if (position === undefined) {\r\n      return this._clones.map((v, i) => map(i));\r\n    }\r\n\r\n    return this._clones.map((v, i) => v === position ? map(i) : null).filter(item => item) as number[];\r\n  }\r\n\r\n  speed(speed?: number): number {\r\n    if (speed !== undefined) {\r\n      this._speed = speed;\r\n    }\r\n\r\n    return this._speed || 0;\r\n  }\r\n\r\n  coordinates(position: number | null | undefined): number | number[] {\r\n    let multiplier = 1,\r\n      newPosition = (position || 0) - 1,\r\n      coordinate,\r\n      result: number[];\r\n\r\n    if (position === undefined) {\r\n      result = this._coordinates.map((_, index) => {\r\n        return this.coordinates(index) as number;\r\n      });\r\n      return result;\r\n    }\r\n\r\n    if (this.settings.center) {\r\n      if (this.settings.rtl) {\r\n        multiplier = -1;\r\n        newPosition = (position || 0) + 1;\r\n      }\r\n\r\n      coordinate = this._coordinates[(position || 0)];\r\n      coordinate += (this.width() - coordinate + (this._coordinates[newPosition] || 0)) / 2 * multiplier;\r\n    } else {\r\n      coordinate = this._coordinates[newPosition] || 0;\r\n    }\r\n\r\n    coordinate = Math.ceil(coordinate);\r\n\r\n    return coordinate;\r\n  }\r\n\r\n  to(position: number, speed: number | boolean) {\r\n    let current = this.current(),\r\n      revert = null,\r\n      distance = position - this.relative(current || 0),\r\n      maximum = this.maximum(),\r\n      delayForLoop = 0;\r\n    const direction = +(distance > 0) - +(distance < 0),\r\n      items = this._items.length,\r\n      minimum = this.minimum();\r\n\r\n    if (this.settings.loop) {\r\n      if (!this.settings.rewind && Math.abs(distance) > items / 2) {\r\n        distance += direction * -1 * items;\r\n      }\r\n\r\n      position = (current || 0) + distance;\r\n      revert = ((position - minimum) % items + items) % items + minimum;\r\n\r\n      if (revert !== position && revert - distance <= maximum && revert - distance > 0) {\r\n        current = revert - distance;\r\n        position = revert;\r\n        delayForLoop = 30;\r\n        this.reset(current);\r\n        this.sendChanges();\r\n      }\r\n    } else if (this.settings.rewind) {\r\n      maximum += 1;\r\n      position = (position % maximum + maximum) % maximum;\r\n    } else {\r\n      position = Math.max(minimum, Math.min(maximum, position));\r\n    }\r\n\r\n    setTimeout(() => {\r\n      this.speed(this.duration(current || 0, position, speed));\r\n      this.current(position);\r\n\r\n      this.update();\r\n    }, delayForLoop);\r\n  }\r\n\r\n  next(speed: number | boolean) {\r\n    speed = speed || false;\r\n    this.to(this.relative(this.current() || 0) + 1, speed);\r\n  }\r\n\r\n  previous(speed: number | boolean) {\r\n    speed = speed || false;\r\n    this.to(this.relative(this.current() || 0) - 1, speed);\r\n  }\r\n\r\n  onTransitionEnd(event?: any) {\r\n    if (!event) {\r\n      this.leave(CarouselEventType.Animating);\r\n      this.trigger(CarouselEventType.Translated);\r\n    }\r\n  }\r\n\r\n  setCurrentSlideClasses(slide: CarouselSlideModel): { [key: string]: boolean } {\r\n    const currentClasses: { [key: string]: boolean } = {\r\n      'active': slide.isActive || false,\r\n      'center': slide.isCentered || false,\r\n      'cloned': slide.isCloned || false,\r\n      'animated': slide.isAnimated || false,\r\n      'animated-in': slide.isDefAnimatedIn || false,\r\n      'animated-out': slide.isDefAnimatedOut || false\r\n    };\r\n    if (this.settings.animateIn) {\r\n      currentClasses[this.settings.animateIn as string] = slide.isCustomAnimatedIn || false;\r\n    }\r\n    if (this.settings.animateOut) {\r\n      currentClasses[this.settings.animateOut as string] = slide.isCustomAnimatedOut || false;\r\n    }\r\n    return currentClasses;\r\n  }\r\n\r\n  enter(name: string) {\r\n    [name].concat(this._states.tags[name] || []).forEach((stateName) => {\r\n      if ((this._states.current as any)[stateName] === undefined) {\r\n        (this._states.current as any)[stateName] = 0;\r\n      }\r\n\r\n      (this._states.current as any)[stateName]++;\r\n    });\r\n  };\r\n\r\n  leave(name: string) {\r\n    [name].concat(this._states.tags[name] || []).forEach((stateName) => {\r\n      if ((this._states.current as any)[stateName] === 0 || !!(this._states.current as any)[stateName]) {\r\n        (this._states.current as any)[stateName]--;\r\n      }\r\n    })\r\n  };\r\n\r\n  private setOptions(options: CarouselOptionsModel) {\r\n    this.options = { ...CarouselServiceConstants.DEFAULT_OPTIONS, ...options };\r\n  }\r\n\r\n  private validateItems(items: number, skip_validateItems: boolean): number {\r\n    let result: number = items;\r\n\r\n    if (items > this._items.length && !skip_validateItems) {\r\n      result = this._items.length;\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  private setCarouselWidth(width: number) {\r\n    this._width = width;\r\n  }\r\n\r\n  private setOptionsForViewport() {\r\n    const viewport = this._width,\r\n      overwrites = this.options.responsive || {};\r\n    let match = -1;\r\n\r\n    if (!Object.keys(overwrites).length) {\r\n      return;\r\n    }\r\n\r\n    if (!viewport) {\r\n      this.settings.items = 1;\r\n      return;\r\n    }\r\n\r\n    for (const key in overwrites) {\r\n      if (overwrites.hasOwnProperty(key)) {\r\n        if (+key <= viewport && +key > match) {\r\n          match = Number(key);\r\n        }\r\n      }\r\n    }\r\n\r\n    this.settings = { ...this.options, ...overwrites[match], items: (overwrites[match] && overwrites[match].items) ? this.validateItems(overwrites[match].items || 0, this.options.skip_validateItems || false) : this.options.items };\r\n\r\n    delete this.settings.responsive;\r\n    this.carouselDOMModel.isResponsive = true;\r\n\r\n    const mergers: any[] = [];\r\n    this._items.forEach(item => {\r\n      const mergeN: number = this.settings.merge ? item.dataMerge : 1;\r\n      mergers.push(mergeN);\r\n    });\r\n    this._mergers = mergers;\r\n\r\n    this.invalidate(CarouselProperty.Settings);\r\n  }\r\n\r\n  private optionsLogic() {\r\n    if (this.settings.autoWidth) {\r\n      this.settings.stagePadding = 0;\r\n      this.settings.merge = false;\r\n    }\r\n  }\r\n\r\n  private update() {\r\n    let i = 0;\r\n    const n = this._pipe.length,\r\n      filter = (item: string | number) => this._invalidated[item],\r\n      cache = {};\r\n\r\n    while (i < n) {\r\n      const filteredPipe = this._pipe[i].filter.filter(filter);\r\n      if (this._invalidated.all || filteredPipe.length > 0) {\r\n        this._pipe[i].run(cache);\r\n      }\r\n      i++;\r\n    }\r\n    this.slidesModel.forEach(slide => slide.classes = this.setCurrentSlideClasses(slide));\r\n    this.sendChanges();\r\n\r\n    this._invalidated = {};\r\n\r\n    if (!this.is('valid')) {\r\n      this.enter('valid');\r\n    }\r\n  }\r\n\r\n  private width(dimension?: Width): number {\r\n    dimension = dimension || Width.Default;\r\n    switch (dimension) {\r\n      case Width.Inner:\r\n      case Width.Outer:\r\n        return this._width;\r\n      default:\r\n        return this._width - (this.settings.stagePadding || 0) * 2 + (this.settings.margin || 0);\r\n    }\r\n  }\r\n\r\n  private refresh() {\r\n    this.enter(CarouselEventType.Refreshing);\r\n    this.trigger(CarouselEventType.Refresh);\r\n    this.defineSlidesData();\r\n    this.setOptionsForViewport();\r\n    this.optionsLogic();\r\n    this.update();\r\n    this.leave(CarouselEventType.Refreshing);\r\n    this.trigger(CarouselEventType.Refreshed);\r\n  }\r\n\r\n  private animate(coordinate: number | number[]) {\r\n    const animate = this.speed() > 0;\r\n\r\n    if (this.is(CarouselEventType.Animating)) {\r\n      this.onTransitionEnd();\r\n    }\r\n\r\n    if (animate) {\r\n      this.enter(CarouselEventType.Animating);\r\n      this.trigger(CarouselEventType.Translate);\r\n    }\r\n\r\n    this.stageModel.transform = 'translate3d(' + coordinate + 'px,0px,0px)';\r\n    this.stageModel.transition = (this.speed() / 1000) + 's' + (\r\n      this.settings.slideTransition ? ' ' + this.settings.slideTransition : ''\r\n    );\r\n  }\r\n\r\n  private invalidate(part: string): string[] {\r\n    if (typeof part === 'string') {\r\n      this._invalidated[part] = true;\r\n      if (this.is('valid')) { this.leave('valid'); }\r\n    }\r\n    return Object.keys(this._invalidated);\r\n  };\r\n\r\n  private reset(position: number) {\r\n    position = this.normalize(position);\r\n\r\n    if (position === undefined) {\r\n      return;\r\n    }\r\n\r\n    this._speed = 0;\r\n    this._current = position;\r\n\r\n    this.suppress([CarouselEventType.Translate, CarouselEventType.Translated]);\r\n\r\n    this.animate(this.coordinates(position));\r\n\r\n    this.release([CarouselEventType.Translate, CarouselEventType.Translated]);\r\n  }\r\n\r\n  private normalize(position: number, relative?: boolean): number {\r\n    const n = this._items.length,\r\n      m = relative ? 0 : this._clones.length;\r\n\r\n    if (!isNumeric(position) || n < 1) {\r\n      position = 0;\r\n    } else if (position < 0 || position >= n + m) {\r\n      position = ((position - m / 2) % n + n) % n + m / 2;\r\n    }\r\n\r\n    return position;\r\n  }\r\n\r\n  private duration(from: number, to: number, factor?: number | boolean): number {\r\n    if (factor === 0) {\r\n      return 0;\r\n    }\r\n\r\n    return Math.min(Math.max(Math.abs(to - from), 1), 6) * Math.abs((+(factor as any)));\r\n  }\r\n\r\n  private setItems(content: CarouselSlideDirective[]) {\r\n    this._items = content;\r\n  }\r\n\r\n  private defineSlidesData() {\r\n    let loadMap: Map<string, boolean>;\r\n\r\n    if (this.slidesModel && this.slidesModel.length) {\r\n      loadMap = new Map();\r\n      this.slidesModel.forEach(item => {\r\n        if (item.load) {\r\n          loadMap.set(item.id, item.load);\r\n        }\r\n      })\r\n    }\r\n\r\n    this.slidesModel = this._items.map(slide => {\r\n      return {\r\n        id: `${slide.id}`,\r\n        isActive: false,\r\n        tplRef: slide.tplRef,\r\n        dataMerge: slide.dataMerge,\r\n        width: 0,\r\n        isCloned: false,\r\n        load: loadMap ? loadMap.get(slide.id) : false,\r\n        classes: {}\r\n      };\r\n    });\r\n  }\r\n\r\n  private op(a: number, o: string, b: number): boolean {\r\n    const rtl = this.settings.rtl;\r\n    switch (o) {\r\n      case '<':\r\n        return rtl ? a > b : a < b;\r\n      case '>':\r\n        return rtl ? a < b : a > b;\r\n      case '>=':\r\n        return rtl ? a <= b : a >= b;\r\n      case '<=':\r\n        return rtl ? a >= b : a <= b;\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  private trigger(name: string, data?: any) {\r\n    switch (name) {\r\n      case CarouselEventType.Initialized:\r\n        this._initializedCarousel$.next(name);\r\n        break;\r\n      case CarouselEventType.Change:\r\n        this._changeSettingsCarousel$.next(data);\r\n        break;\r\n      case CarouselEventType.Changed:\r\n        this._changedSettingsCarousel$.next(data);\r\n        break;\r\n      case CarouselEventType.Resize:\r\n        this._resizeCarousel$.next(name);\r\n        break;\r\n      case CarouselEventType.Resized:\r\n        this._resizedCarousel$.next(name);\r\n        break;\r\n      case CarouselEventType.Refresh:\r\n        this._refreshCarousel$.next(name);\r\n        break;\r\n      case CarouselEventType.Refreshed:\r\n        this._refreshedCarousel$.next(name);\r\n        break;\r\n      case CarouselEventType.Translate:\r\n        this._translateCarousel$.next(name);\r\n        break;\r\n      case CarouselEventType.Translated:\r\n        this._translatedCarousel$.next(name);\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n  }\r\n\r\n  private suppress(events: string[]) {\r\n    events.forEach(event => {\r\n      this._supress[event] = true;\r\n    });\r\n  }\r\n\r\n  private release(events: string[]) {\r\n    events.forEach(event => {\r\n      delete this._supress[event];\r\n    });\r\n  }\r\n}\r\n"]}