intia-theme 0.1.0 → 0.1.4

data/node_modules/bulma-carousel/src/js/components/breakpoint.js

@@ -0,0 +1,91 @@
+const onResize = Symbol('onResize');
+
+export default class Breakpoints {
+	constructor(slider) {
+		this.slider = slider;
+		this.options = slider.options;
+
+		this[onResize] = this[onResize].bind(this);
+
+		this._bindEvents();
+	}
+
+	init() {
+		this._defaultBreakpoint = {
+			slidesToShow: this.options.slidesToShow,
+			slidesToScroll: this.options.slidesToScroll
+		};
+		this.options.breakpoints.sort(function (a, b) {
+			return parseInt(a.changePoint, 10) > parseInt(b.changePoint, 10);
+		});
+		this._currentBreakpoint = this._getActiveBreakpoint();
+
+		return this;
+	}
+
+	destroy() {
+		this._unbindEvents();
+	}
+
+	_bindEvents() {
+		window.addEventListener('resize', this[onResize]);
+		window.addEventListener('orientationchange', this[onResize]);
+	}
+
+	_unbindEvents() {
+		window.removeEventListener('resize', this[onResize]);
+		window.removeEventListener('orientationchange', this[onResize]);
+	}
+
+	_getActiveBreakpoint() {
+		//Get breakpoint for window width
+		for (let point of this.options.breakpoints) {
+			if (point.changePoint >= window.innerWidth) {
+				return point;
+			}
+		}
+		return this._defaultBreakpoint;
+	}
+
+	getSlidesToShow() {
+		return this._currentBreakpoint ? this._currentBreakpoint.slidesToShow : this._defaultBreakpoint.slidesToShow;
+	}
+
+	getSlidesToScroll() {
+		return this._currentBreakpoint ? this._currentBreakpoint.slidesToScroll : this._defaultBreakpoint.slidesToScroll;
+	}
+
+	apply() {
+		if (this.slider.state.index >= this.slider.state.length && this.slider.state.index !== 0) {
+			this.slider.state.index = this.slider.state.index - this._currentBreakpoint.slidesToScroll;
+		}
+		if (this.slider.state.length <= this._currentBreakpoint.slidesToShow) {
+			this.slider.state.index = 0;
+		}
+
+		if (this.options.loop) {
+			this.slider._loop.init().apply();
+		}
+
+		if (this.options.infinite) {
+			this.slider._infinite.init().apply();
+		}
+
+		this.slider._setDimensions();
+		this.slider._transitioner.init().apply(true, this.slider._setHeight.bind(this.slider));
+		this.slider._setClasses();
+
+		this.slider._navigation.refresh();
+		this.slider._pagination.refresh();
+	}
+
+	[onResize](e) {
+		let newBreakPoint = this._getActiveBreakpoint();
+		if (newBreakPoint.slidesToShow !== this._currentBreakpoint.slidesToShow) {
+			this._currentBreakpoint = newBreakPoint;
+			this.apply();
+		} else {
+			this.slider._setDimensions();
+		}
+	}
+}

data/node_modules/bulma-carousel/src/js/components/infinite.js

@@ -0,0 +1,60 @@
+export default class Infinite {
+	constructor(slider) {
+		this.slider = slider;
+	}
+
+	init() {
+		if (this.slider.options.infinite && this.slider.options.effect === 'translate') {
+			if (this.slider.options.centerMode) {
+				this._infiniteCount = Math.ceil(this.slider.slidesToShow + (this.slider.slidesToShow / 2));
+			} else {
+				this._infiniteCount = this.slider.slidesToShow;
+			}
+
+			let frontClones = [];
+			let slideIndex = 0;
+			for (let i = this.slider.state.length; i > (this.slider.state.length - 1 - this._infiniteCount); i -= 1) {
+				slideIndex = (this.slider.state.length * Math.floor(this._infiniteCount / this.slider.state.length) + i - 1) % this.slider.state.length;
+				frontClones.unshift(this._cloneSlide(this.slider.slides[slideIndex], slideIndex - this.slider.state.length));
+			}
+
+			let backClones = [];
+			for (let i = 0; i < this._infiniteCount + this.slider.state.length; i += 1) {
+				backClones.push(this._cloneSlide(this.slider.slides[i % this.slider.state.length], i + this.slider.state.length));
+			}
+
+			this.slider.slides = [
+				...frontClones,
+				...this.slider.slides,
+				...backClones
+			];
+		}
+		return this;
+	}
+
+	apply() {
+	}
+
+	onTransitionEnd(e) {
+		if (this.slider.options.infinite) {
+			if (this.slider.state.next >= this.slider.state.length) {
+				this.slider.state.index = this.slider.state.next = this.slider.state.next - this.slider.state.length;
+				this.slider.transitioner.apply(true);
+			} else if (this.slider.state.next < 0) {
+				this.slider.state.index = this.slider.state.next = this.slider.state.length + this.slider.state.next;
+				this.slider.transitioner.apply(true);
+			}
+		}
+	}
+
+	_cloneSlide(slide, index) {
+		const newSlide = slide.cloneNode(true);
+		newSlide.dataset.sliderIndex = index;
+		newSlide.dataset.cloned = true;
+		const ids = newSlide.querySelectorAll('[id]') || [];
+		ids.forEach(id => {
+			id.setAttribute('id', '');
+		});
+		return newSlide;
+	}
+}

data/node_modules/bulma-carousel/src/js/components/loop.js

@@ -0,0 +1,35 @@
+import {
+	isInViewport
+} from "../utils/dom";
+
+export default class Loop {
+	constructor(slider) {
+		this.slider = slider;
+	}
+
+	init() {
+		return this;
+	}
+
+	apply() {
+		if (this.slider.options.loop) {
+			if (this.slider.state.next > 0) {
+				if (this.slider.state.next < this.slider.state.length) {
+					if (this.slider.state.next > this.slider.state.length - this.slider.slidesToShow && isInViewport(this.slider._slides[this.slider.state.length - 1], this.slider.wrapper)) {
+						this.slider.state.next = 0;
+					} else {
+						this.slider.state.next = Math.min(Math.max(this.slider.state.next, 0), this.slider.state.length - this.slider.slidesToShow);
+					}
+				} else {
+					this.slider.state.next = 0;
+				}
+			} else {
+				if (this.slider.state.next <= 0 - (this.slider.slidesToScroll)) {
+					this.slider.state.next = this.slider.state.length - this.slider.slidesToShow;
+				} else {
+					this.slider.state.next = 0;
+				}
+			}
+		}
+	}
+}

data/node_modules/bulma-carousel/src/js/components/navigation.js

@@ -0,0 +1,107 @@
+import template from '../templates/navigation';
+import detectSupportsPassive from '../utils/detect-supportsPassive';
+
+export default class Navigation {
+	constructor(slider) {
+		this.slider = slider;
+
+		this._clickEvents = ['click', 'touch'];
+		this._supportsPassive = detectSupportsPassive();
+
+		this.onPreviousClick = this.onPreviousClick.bind(this);
+		this.onNextClick = this.onNextClick.bind(this);
+		this.onKeyUp = this.onKeyUp.bind(this);
+	}
+
+	init() {
+		this.node = document.createRange().createContextualFragment(template(this.slider.options.icons));
+		this._ui = {
+			previous: this.node.querySelector('.slider-navigation-previous'),
+			next: this.node.querySelector('.slider-navigation-next')
+		};
+
+		this._unbindEvents();
+		this._bindEvents();
+
+		this.refresh();
+
+		return this;
+	}
+
+	destroy() {
+		this._unbindEvents();
+	}
+
+	_bindEvents() {
+		this.slider.wrapper.addEventListener('keyup', this.onKeyUp);
+		this._clickEvents.forEach(clickEvent => {
+			this._ui.previous.addEventListener(clickEvent, this.onPreviousClick);
+			this._ui.next.addEventListener(clickEvent, this.onNextClick);
+		});
+	}
+
+	_unbindEvents() {
+		this.slider.wrapper.removeEventListener('keyup', this.onKeyUp);
+		this._clickEvents.forEach(clickEvent => {
+			this._ui.previous.removeEventListener(clickEvent, this.onPreviousClick);
+			this._ui.next.removeEventListener(clickEvent, this.onNextClick);
+		});
+	}
+
+	onNextClick(e) {
+		if (!this._supportsPassive) {
+			e.preventDefault();
+		}
+
+		if (this.slider.options.navigation) {
+			this.slider.next();
+		}
+	}
+
+	onPreviousClick(e) {
+		if (!this._supportsPassive) {
+			e.preventDefault();
+		}
+
+		if (this.slider.options.navigation) {
+			this.slider.previous();
+		}
+	}
+
+	onKeyUp(e) {
+		if (this.slider.options.keyNavigation) {
+			if (e.key === 'ArrowRight' || e.key === 'Right') {
+				this.slider.next();
+			} else if (e.key === 'ArrowLeft' || e.key === 'Left') {
+				this.slider.previous();
+			}
+		}
+	}
+
+	refresh() {
+		// let centerOffset = Math.floor(this.options.slidesToShow / 2);
+		if (!this.slider.options.loop && !this.slider.options.infinite) {
+			if (this.slider.options.navigation && this.slider.state.length > this.slider.slidesToShow) {
+				this._ui.previous.classList.remove('is-hidden');
+				this._ui.next.classList.remove('is-hidden');
+				if (this.slider.state.next === 0) {
+					this._ui.previous.classList.add('is-hidden');
+					this._ui.next.classList.remove('is-hidden');
+				} else if (this.slider.state.next >= this.slider.state.length - this.slider.slidesToShow && !this.slider.options.centerMode) {
+					this._ui.previous.classList.remove('is-hidden');
+					this._ui.next.classList.add('is-hidden');
+				} else if (this.slider.state.next >= this.slider.state.length - 1 && this.slider.options.centerMode) {
+					this._ui.previous.classList.remove('is-hidden');
+					this._ui.next.classList.add('is-hidden');
+				}
+			} else {
+				this._ui.previous.classList.add('is-hidden');
+				this._ui.next.classList.add('is-hidden');
+			}
+		}
+	}
+
+	render() {
+		return this.node;
+	}
+}

data/node_modules/bulma-carousel/src/js/components/pagination.js

@@ -0,0 +1,103 @@
+import template from '../templates/pagination';
+import templatePage from '../templates/pagination-page';
+import detectSupportsPassive from '../utils/detect-supportsPassive';
+
+export default class Pagination {
+	constructor(slider) {
+		this.slider = slider;
+
+		this._clickEvents = ['click', 'touch'];
+		this._supportsPassive = detectSupportsPassive();
+
+		this.onPageClick = this.onPageClick.bind(this);
+		this.onResize = this.onResize.bind(this);
+	}
+
+	init() {
+		this._pages = [];
+		this.node = document.createRange().createContextualFragment(template());
+		this._ui = {
+			container: this.node.firstChild
+		};
+
+		this._count = Math.ceil((this.slider.state.length - this.slider.slidesToShow) / this.slider.slidesToScroll);
+
+		this._draw();
+		this.refresh();
+
+		return this;
+	}
+
+	destroy() {
+		this._unbindEvents();
+	}
+
+	_bindEvents() {
+		window.addEventListener('resize', this.onResize);
+		window.addEventListener('orientationchange', this.onResize);
+
+		this._clickEvents.forEach(clickEvent => {
+			this._pages.forEach(page => page.addEventListener(clickEvent, this.onPageClick));
+		});
+	}
+
+	_unbindEvents() {
+		window.removeEventListener('resize', this.onResize);
+		window.removeEventListener('orientationchange', this.onResize);
+
+		this._clickEvents.forEach(clickEvent => {
+			this._pages.forEach(page => page.removeEventListener(clickEvent, this.onPageClick));
+		});
+	}
+
+	_draw() {
+		this._ui.container.innerHTML = '';
+		if (this.slider.options.pagination && this.slider.state.length > this.slider.slidesToShow) {
+			for (let i = 0; i <= this._count; i++) {
+				const newPageNode = document.createRange().createContextualFragment(templatePage()).firstChild;
+				newPageNode.dataset.index = i * this.slider.slidesToScroll;
+				this._pages.push(newPageNode);
+				this._ui.container.appendChild(newPageNode);
+			}
+			this._bindEvents();
+		}
+	}
+
+	onPageClick(e) {
+		if (!this._supportsPassive) {
+			e.preventDefault();
+		}
+
+		this.slider.state.next = e.currentTarget.dataset.index;
+		this.slider.show();
+	}
+
+	onResize() {
+		this._draw();
+	}
+
+	refresh() {
+		let newCount;
+
+		if (this.slider.options.infinite) {
+			newCount = Math.ceil(this.slider.state.length - 1 / this.slider.slidesToScroll);
+		} else {
+			newCount = Math.ceil((this.slider.state.length - this.slider.slidesToShow) / this.slider.slidesToScroll);
+		}
+		if (newCount !== this._count) {
+			this._count = newCount;
+			this._draw();
+		}
+
+		this._pages.forEach(page => {
+			page.classList.remove('is-active');
+			if (parseInt(page.dataset.index, 10) === this.slider.state.next % this.slider.state.length) {
+				page.classList.add('is-active');
+			}
+		});
+	}
+
+	render() {
+		return this.node;
+	}
+}

data/node_modules/bulma-carousel/src/js/components/swipe.js

@@ -0,0 +1,106 @@
+import Coordinate from '../utils/coordinate';
+import detectSupportsPassive from '../utils/detect-supportsPassive';
+
+export default class Swipe {
+	constructor(slider) {
+		this.slider = slider;
+
+		this._supportsPassive = detectSupportsPassive();
+
+		this.onStartDrag = this.onStartDrag.bind(this);
+		this.onMoveDrag = this.onMoveDrag.bind(this);
+		this.onStopDrag = this.onStopDrag.bind(this);
+
+		this._init();
+	}
+
+	_init() {}
+
+	bindEvents() {
+		this.slider.container.addEventListener('dragstart', e => {
+			if (!this._supportsPassive) {
+				e.preventDefault();
+			}
+		});
+		this.slider.container.addEventListener('mousedown', this.onStartDrag);
+		this.slider.container.addEventListener('touchstart', this.onStartDrag);
+
+		window.addEventListener('mousemove', this.onMoveDrag);
+		window.addEventListener('touchmove', this.onMoveDrag);
+
+		window.addEventListener('mouseup', this.onStopDrag);
+		window.addEventListener('touchend', this.onStopDrag);
+		window.addEventListener('touchcancel', this.onStopDrag);
+	}
+
+	unbindEvents() {
+		this.slider.container.removeEventListener('dragstart', e => {
+			if (!this._supportsPassive) {
+				e.preventDefault();
+			}
+		});
+		this.slider.container.removeEventListener('mousedown', this.onStartDrag);
+		this.slider.container.removeEventListener('touchstart', this.onStartDrag);
+
+		window.removeEventListener('mousemove', this.onMoveDrag);
+		window.removeEventListener('touchmove', this.onMoveDrag);
+
+		window.removeEventListener('mouseup', this.onStopDrag);
+		window.removeEventListener('mouseup', this.onStopDrag);
+		window.removeEventListener('touchcancel', this.onStopDrag);
+	}
+
+	/**
+	 * @param {MouseEvent|TouchEvent}
+	 */
+	onStartDrag(e) {
+		if (e.touches) {
+			if (e.touches.length > 1) {
+				return;
+			} else {
+				e = e.touches[0];
+			}
+		}
+
+		this._origin = new Coordinate(e.screenX, e.screenY);
+		this.width = this.slider.wrapperWidth;
+		this.slider.transitioner.disable();
+	}
+
+	/**
+	 * @param {MouseEvent|TouchEvent}
+	 */
+	onMoveDrag(e) {
+		if (this._origin) {
+			let point = e.touches ? e.touches[0] : e;
+			this._lastTranslate = new Coordinate(point.screenX - this._origin.x, point.screenY - this._origin.y);
+			if (e.touches) {
+				if (Math.abs(this._lastTranslate.x) > Math.abs(this._lastTranslate.y)) {
+					if (!this._supportsPassive) {
+						e.preventDefault();
+					}
+					e.stopPropagation();
+				}
+			}
+		}
+	}
+
+	/**
+	 * @param {MouseEvent|TouchEvent}
+	 */
+	onStopDrag(e) {
+		if (this._origin && this._lastTranslate) {
+			if (Math.abs(this._lastTranslate.x) > 0.2 * this.width) {
+				if (this._lastTranslate.x < 0) {
+					this.slider.next();
+				} else {
+					this.slider.previous();
+				}
+			} else {
+				this.slider.show(true);
+			}
+		}
+		this._origin = null;
+		this._lastTranslate = null;
+	}
+}

data/node_modules/bulma-carousel/src/js/components/transitioner.js

@@ -0,0 +1,74 @@
+import Fade from './transitions/fade';
+import Translate from './transitions/translate';
+
+export default class Transitioner {
+	constructor(slider) {
+		this.slider = slider;
+		this.options = slider.options;
+
+		this._animating = false;
+		this._animation = undefined;
+
+		this._translate = new Translate(this, slider, slider.options);
+		this._fade = new Fade(this, slider, slider.options);
+	}
+
+	init() {
+		this._fade.init();
+		this._translate.init();
+		return this;
+	}
+
+	isAnimating() {
+		return this._animating;
+	}
+
+	enable() {
+		this._animation && this._animation.enable();
+	}
+
+	disable() {
+		this._animation && this._animation.disable();
+	}
+
+	apply(force, callback) {
+		// If we don't force refresh and animation in progress then return
+		if (this._animating && !force) {
+			return;
+		}
+
+		switch (this.options.effect) {
+			case 'fade':
+				this._animation = this._fade;
+				break;
+			case 'translate':
+			default:
+				this._animation = this._translate;
+				break;
+		}
+
+		this._animationCallback = callback;
+
+		if (force) {
+			this._animation && this._animation.disable();
+		} else {
+			this._animation && this._animation.enable();
+			this._animating = true;
+		}
+
+		this._animation && this._animation.apply();
+
+		if (force) {
+			this.end();
+		}
+	}
+
+	end() {
+		this._animating = false;
+		this._animation = undefined;
+		this.slider.state.index = this.slider.state.next;
+		if (this._animationCallback) {
+			this._animationCallback();
+		}
+	}
+}

data/node_modules/bulma-carousel/src/js/components/transitions/fade.js

@@ -0,0 +1,90 @@
+import {
+	css
+} from '../../utils/css';
+
+export default class Fade {
+	constructor(transitioner, slider, options = {}) {
+		this.transitioner = transitioner;
+		this.slider = slider;
+		this.options = {
+			...options
+		};
+	}
+
+	init() {
+		if (this.options.effect === 'fade') {
+			this.slider.slides.forEach((slide, index) => {
+				css(slide, {
+					position: 'absolute',
+					left: 0,
+					top: 0,
+					bottom: 0,
+					'z-index': slide.dataset.sliderIndex == this.slider.state.index ? 0 : -2,
+					opacity: slide.dataset.sliderIndex == this.slider.state.index ? 1 : 0
+				});
+			});
+		}
+		return this;
+	}
+
+	enable() {
+		this._oldSlide = this.slider.slides.filter(slide => slide.dataset.sliderIndex == this.slider.state.index)[0];
+		this._newSlide = this.slider.slides.filter(slide => slide.dataset.sliderIndex == this.slider.state.next)[0];
+		if (this._newSlide) {
+			this._newSlide.addEventListener('transitionend', this.onTransitionEnd.bind(this));
+			this._newSlide.style.transition = `${this.options.duration}ms ${this.options.timing}`;
+			if (this._oldSlide) {
+				this._oldSlide.addEventListener('transitionend', this.onTransitionEnd.bind(this));
+				this._oldSlide.style.transition = `${this.options.duration}ms ${this.options.timing}`;
+			}
+		}
+	}
+
+	disable() {
+		this._oldSlide = this.slider.slides.filter(slide => slide.dataset.sliderIndex == this.slider.state.index)[0];
+		this._newSlide = this.slider.slides.filter(slide => slide.dataset.sliderIndex == this.slider.state.next)[0];
+		if (this._newSlide) {
+			this._newSlide.removeEventListener('transitionend', this.onTransitionEnd.bind(this));
+			this._newSlide.style.transition = `none`;
+			if (this._oldSlide) {
+				this._oldSlide.removeEventListener('transitionend', this.onTransitionEnd.bind(this));
+				this._oldSlide.style.transition = `none`;
+			}
+		}
+	}
+
+	apply(force) {
+		this._oldSlide = this.slider.slides.filter(slide => slide.dataset.sliderIndex == this.slider.state.index)[0];
+		this._newSlide = this.slider.slides.filter(slide => slide.dataset.sliderIndex == this.slider.state.next)[0];
+		
+		if (this._oldSlide && this._newSlide) {
+			css(this._oldSlide, {
+				opacity: 0
+			});
+			css(this._newSlide, {
+				opacity: 1,
+				'z-index': force ? 0 : -1
+			});
+		}
+	}
+
+	onTransitionEnd(e) {
+		if (this.options.effect === 'fade') {
+			if (this.transitioner.isAnimating() && e.target == this._newSlide) {
+				if (this._newSlide) {
+					css(this._newSlide, {
+						'z-index': 0
+					});
+					this._newSlide.removeEventListener('transitionend', this.onTransitionEnd.bind(this));
+				}
+				if (this._oldSlide) {
+					css(this._oldSlide, {
+						'z-index': -2
+					});
+					this._oldSlide.removeEventListener('transitionend', this.onTransitionEnd.bind(this));
+				}
+			}
+			this.transitioner.end();
+		}
+	}
+}