correction && add form && add slide && add masonry && css
This commit is contained in:
BIN
node_modules/flickity/js/.DS_Store
generated
vendored
Normal file
BIN
node_modules/flickity/js/.DS_Store
generated
vendored
Normal file
Binary file not shown.
161
node_modules/flickity/js/add-remove-cell.js
generated
vendored
Normal file
161
node_modules/flickity/js/add-remove-cell.js
generated
vendored
Normal file
@@ -0,0 +1,161 @@
|
||||
// add, remove cell
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'./flickity',
|
||||
'fizzy-ui-utils/utils'
|
||||
], function( Flickity, utils ) {
|
||||
return factory( window, Flickity, utils );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('./flickity'),
|
||||
require('fizzy-ui-utils')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
factory(
|
||||
window,
|
||||
window.Flickity,
|
||||
window.fizzyUIUtils
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, Flickity, utils ) {
|
||||
|
||||
'use strict';
|
||||
|
||||
// append cells to a document fragment
|
||||
function getCellsFragment( cells ) {
|
||||
var fragment = document.createDocumentFragment();
|
||||
cells.forEach( function( cell ) {
|
||||
fragment.appendChild( cell.element );
|
||||
});
|
||||
return fragment;
|
||||
}
|
||||
|
||||
// -------------------------- add/remove cell prototype -------------------------- //
|
||||
|
||||
var proto = Flickity.prototype;
|
||||
|
||||
/**
|
||||
* Insert, prepend, or append cells
|
||||
* @param {Element, Array, NodeList} elems
|
||||
* @param {Integer} index
|
||||
*/
|
||||
proto.insert = function( elems, index ) {
|
||||
var cells = this._makeCells( elems );
|
||||
if ( !cells || !cells.length ) {
|
||||
return;
|
||||
}
|
||||
var len = this.cells.length;
|
||||
// default to append
|
||||
index = index === undefined ? len : index;
|
||||
// add cells with document fragment
|
||||
var fragment = getCellsFragment( cells );
|
||||
// append to slider
|
||||
var isAppend = index == len;
|
||||
if ( isAppend ) {
|
||||
this.slider.appendChild( fragment );
|
||||
} else {
|
||||
var insertCellElement = this.cells[ index ].element;
|
||||
this.slider.insertBefore( fragment, insertCellElement );
|
||||
}
|
||||
// add to this.cells
|
||||
if ( index === 0 ) {
|
||||
// prepend, add to start
|
||||
this.cells = cells.concat( this.cells );
|
||||
} else if ( isAppend ) {
|
||||
// append, add to end
|
||||
this.cells = this.cells.concat( cells );
|
||||
} else {
|
||||
// insert in this.cells
|
||||
var endCells = this.cells.splice( index, len - index );
|
||||
this.cells = this.cells.concat( cells ).concat( endCells );
|
||||
}
|
||||
|
||||
this._sizeCells( cells );
|
||||
this.cellChange( index, true );
|
||||
};
|
||||
|
||||
proto.append = function( elems ) {
|
||||
this.insert( elems, this.cells.length );
|
||||
};
|
||||
|
||||
proto.prepend = function( elems ) {
|
||||
this.insert( elems, 0 );
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove cells
|
||||
* @param {Element, Array, NodeList} elems
|
||||
*/
|
||||
proto.remove = function( elems ) {
|
||||
var cells = this.getCells( elems );
|
||||
if ( !cells || !cells.length ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var minCellIndex = this.cells.length - 1;
|
||||
// remove cells from collection & DOM
|
||||
cells.forEach( function( cell ) {
|
||||
cell.remove();
|
||||
var index = this.cells.indexOf( cell );
|
||||
minCellIndex = Math.min( index, minCellIndex );
|
||||
utils.removeFrom( this.cells, cell );
|
||||
}, this );
|
||||
|
||||
this.cellChange( minCellIndex, true );
|
||||
};
|
||||
|
||||
/**
|
||||
* logic to be run after a cell's size changes
|
||||
* @param {Element} elem - cell's element
|
||||
*/
|
||||
proto.cellSizeChange = function( elem ) {
|
||||
var cell = this.getCell( elem );
|
||||
if ( !cell ) {
|
||||
return;
|
||||
}
|
||||
cell.getSize();
|
||||
|
||||
var index = this.cells.indexOf( cell );
|
||||
this.cellChange( index );
|
||||
};
|
||||
|
||||
/**
|
||||
* logic any time a cell is changed: added, removed, or size changed
|
||||
* @param {Integer} changedCellIndex - index of the changed cell, optional
|
||||
*/
|
||||
proto.cellChange = function( changedCellIndex, isPositioningSlider ) {
|
||||
var prevSelectedElem = this.selectedElement;
|
||||
this._positionCells( changedCellIndex );
|
||||
this._getWrapShiftCells();
|
||||
this.setGallerySize();
|
||||
// update selectedIndex
|
||||
// try to maintain position & select previous selected element
|
||||
var cell = this.getCell( prevSelectedElem );
|
||||
if ( cell ) {
|
||||
this.selectedIndex = this.getCellSlideIndex( cell );
|
||||
}
|
||||
this.selectedIndex = Math.min( this.slides.length - 1, this.selectedIndex );
|
||||
|
||||
this.emitEvent( 'cellChange', [ changedCellIndex ] );
|
||||
// position slider
|
||||
this.select( this.selectedIndex );
|
||||
// do not position slider after lazy load
|
||||
if ( isPositioningSlider ) {
|
||||
this.positionSliderAtSelected();
|
||||
}
|
||||
};
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
201
node_modules/flickity/js/animate.js
generated
vendored
Normal file
201
node_modules/flickity/js/animate.js
generated
vendored
Normal file
@@ -0,0 +1,201 @@
|
||||
// animate
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'fizzy-ui-utils/utils'
|
||||
], function( utils ) {
|
||||
return factory( window, utils );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('fizzy-ui-utils')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
window.Flickity = window.Flickity || {};
|
||||
window.Flickity.animatePrototype = factory(
|
||||
window,
|
||||
window.fizzyUIUtils
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, utils ) {
|
||||
|
||||
'use strict';
|
||||
|
||||
// -------------------------- animate -------------------------- //
|
||||
|
||||
var proto = {};
|
||||
|
||||
proto.startAnimation = function() {
|
||||
if ( this.isAnimating ) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.isAnimating = true;
|
||||
this.restingFrames = 0;
|
||||
this.animate();
|
||||
};
|
||||
|
||||
proto.animate = function() {
|
||||
this.applyDragForce();
|
||||
this.applySelectedAttraction();
|
||||
|
||||
var previousX = this.x;
|
||||
|
||||
this.integratePhysics();
|
||||
this.positionSlider();
|
||||
this.settle( previousX );
|
||||
// animate next frame
|
||||
if ( this.isAnimating ) {
|
||||
var _this = this;
|
||||
requestAnimationFrame( function animateFrame() {
|
||||
_this.animate();
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
proto.positionSlider = function() {
|
||||
var x = this.x;
|
||||
// wrap position around
|
||||
if ( this.options.wrapAround && this.cells.length > 1 ) {
|
||||
x = utils.modulo( x, this.slideableWidth );
|
||||
x = x - this.slideableWidth;
|
||||
this.shiftWrapCells( x );
|
||||
}
|
||||
|
||||
this.setTranslateX( x, this.isAnimating );
|
||||
this.dispatchScrollEvent();
|
||||
};
|
||||
|
||||
proto.setTranslateX = function( x, is3d ) {
|
||||
x += this.cursorPosition;
|
||||
// reverse if right-to-left and using transform
|
||||
x = this.options.rightToLeft ? -x : x;
|
||||
var translateX = this.getPositionValue( x );
|
||||
// use 3D tranforms for hardware acceleration on iOS
|
||||
// but use 2D when settled, for better font-rendering
|
||||
this.slider.style.transform = is3d ?
|
||||
'translate3d(' + translateX + ',0,0)' : 'translateX(' + translateX + ')';
|
||||
};
|
||||
|
||||
proto.dispatchScrollEvent = function() {
|
||||
var firstSlide = this.slides[0];
|
||||
if ( !firstSlide ) {
|
||||
return;
|
||||
}
|
||||
var positionX = -this.x - firstSlide.target;
|
||||
var progress = positionX / this.slidesWidth;
|
||||
this.dispatchEvent( 'scroll', null, [ progress, positionX ] );
|
||||
};
|
||||
|
||||
proto.positionSliderAtSelected = function() {
|
||||
if ( !this.cells.length ) {
|
||||
return;
|
||||
}
|
||||
this.x = -this.selectedSlide.target;
|
||||
this.velocity = 0; // stop wobble
|
||||
this.positionSlider();
|
||||
};
|
||||
|
||||
proto.getPositionValue = function( position ) {
|
||||
if ( this.options.percentPosition ) {
|
||||
// percent position, round to 2 digits, like 12.34%
|
||||
return ( Math.round( ( position / this.size.innerWidth ) * 10000 ) * 0.01 )+ '%';
|
||||
} else {
|
||||
// pixel positioning
|
||||
return Math.round( position ) + 'px';
|
||||
}
|
||||
};
|
||||
|
||||
proto.settle = function( previousX ) {
|
||||
// keep track of frames where x hasn't moved
|
||||
if ( !this.isPointerDown && Math.round( this.x * 100 ) == Math.round( previousX * 100 ) ) {
|
||||
this.restingFrames++;
|
||||
}
|
||||
// stop animating if resting for 3 or more frames
|
||||
if ( this.restingFrames > 2 ) {
|
||||
this.isAnimating = false;
|
||||
delete this.isFreeScrolling;
|
||||
// render position with translateX when settled
|
||||
this.positionSlider();
|
||||
this.dispatchEvent( 'settle', null, [ this.selectedIndex ] );
|
||||
}
|
||||
};
|
||||
|
||||
proto.shiftWrapCells = function( x ) {
|
||||
// shift before cells
|
||||
var beforeGap = this.cursorPosition + x;
|
||||
this._shiftCells( this.beforeShiftCells, beforeGap, -1 );
|
||||
// shift after cells
|
||||
var afterGap = this.size.innerWidth - ( x + this.slideableWidth + this.cursorPosition );
|
||||
this._shiftCells( this.afterShiftCells, afterGap, 1 );
|
||||
};
|
||||
|
||||
proto._shiftCells = function( cells, gap, shift ) {
|
||||
for ( var i=0; i < cells.length; i++ ) {
|
||||
var cell = cells[i];
|
||||
var cellShift = gap > 0 ? shift : 0;
|
||||
cell.wrapShift( cellShift );
|
||||
gap -= cell.size.outerWidth;
|
||||
}
|
||||
};
|
||||
|
||||
proto._unshiftCells = function( cells ) {
|
||||
if ( !cells || !cells.length ) {
|
||||
return;
|
||||
}
|
||||
for ( var i=0; i < cells.length; i++ ) {
|
||||
cells[i].wrapShift( 0 );
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------- physics -------------------------- //
|
||||
|
||||
proto.integratePhysics = function() {
|
||||
this.x += this.velocity;
|
||||
this.velocity *= this.getFrictionFactor();
|
||||
};
|
||||
|
||||
proto.applyForce = function( force ) {
|
||||
this.velocity += force;
|
||||
};
|
||||
|
||||
proto.getFrictionFactor = function() {
|
||||
return 1 - this.options[ this.isFreeScrolling ? 'freeScrollFriction' : 'friction' ];
|
||||
};
|
||||
|
||||
proto.getRestingPosition = function() {
|
||||
// my thanks to Steven Wittens, who simplified this math greatly
|
||||
return this.x + this.velocity / ( 1 - this.getFrictionFactor() );
|
||||
};
|
||||
|
||||
proto.applyDragForce = function() {
|
||||
if ( !this.isDraggable || !this.isPointerDown ) {
|
||||
return;
|
||||
}
|
||||
// change the position to drag position by applying force
|
||||
var dragVelocity = this.dragX - this.x;
|
||||
var dragForce = dragVelocity - this.velocity;
|
||||
this.applyForce( dragForce );
|
||||
};
|
||||
|
||||
proto.applySelectedAttraction = function() {
|
||||
// do not attract if pointer down or no slides
|
||||
var dragDown = this.isDraggable && this.isPointerDown;
|
||||
if ( dragDown || this.isFreeScrolling || !this.slides.length ) {
|
||||
return;
|
||||
}
|
||||
var distance = this.selectedSlide.target * -1 - this.x;
|
||||
var force = distance * this.options.selectedAttraction;
|
||||
this.applyForce( force );
|
||||
};
|
||||
|
||||
return proto;
|
||||
|
||||
}));
|
||||
102
node_modules/flickity/js/cell.js
generated
vendored
Normal file
102
node_modules/flickity/js/cell.js
generated
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
// Flickity.Cell
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'get-size/get-size'
|
||||
], function( getSize ) {
|
||||
return factory( window, getSize );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('get-size')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
window.Flickity = window.Flickity || {};
|
||||
window.Flickity.Cell = factory(
|
||||
window,
|
||||
window.getSize
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, getSize ) {
|
||||
|
||||
'use strict';
|
||||
|
||||
function Cell( elem, parent ) {
|
||||
this.element = elem;
|
||||
this.parent = parent;
|
||||
|
||||
this.create();
|
||||
}
|
||||
|
||||
var proto = Cell.prototype;
|
||||
|
||||
proto.create = function() {
|
||||
this.element.style.position = 'absolute';
|
||||
this.element.setAttribute( 'aria-hidden', 'true' );
|
||||
this.x = 0;
|
||||
this.shift = 0;
|
||||
};
|
||||
|
||||
proto.destroy = function() {
|
||||
// reset style
|
||||
this.unselect();
|
||||
this.element.style.position = '';
|
||||
var side = this.parent.originSide;
|
||||
this.element.style[ side ] = '';
|
||||
};
|
||||
|
||||
proto.getSize = function() {
|
||||
this.size = getSize( this.element );
|
||||
};
|
||||
|
||||
proto.setPosition = function( x ) {
|
||||
this.x = x;
|
||||
this.updateTarget();
|
||||
this.renderPosition( x );
|
||||
};
|
||||
|
||||
// setDefaultTarget v1 method, backwards compatibility, remove in v3
|
||||
proto.updateTarget = proto.setDefaultTarget = function() {
|
||||
var marginProperty = this.parent.originSide == 'left' ? 'marginLeft' : 'marginRight';
|
||||
this.target = this.x + this.size[ marginProperty ] +
|
||||
this.size.width * this.parent.cellAlign;
|
||||
};
|
||||
|
||||
proto.renderPosition = function( x ) {
|
||||
// render position of cell with in slider
|
||||
var side = this.parent.originSide;
|
||||
this.element.style[ side ] = this.parent.getPositionValue( x );
|
||||
};
|
||||
|
||||
proto.select = function() {
|
||||
this.element.classList.add('is-selected');
|
||||
this.element.removeAttribute('aria-hidden');
|
||||
};
|
||||
|
||||
proto.unselect = function() {
|
||||
this.element.classList.remove('is-selected');
|
||||
this.element.setAttribute( 'aria-hidden', 'true' );
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {Integer} factor - 0, 1, or -1
|
||||
**/
|
||||
proto.wrapShift = function( shift ) {
|
||||
this.shift = shift;
|
||||
this.renderPosition( this.x + this.parent.slideableWidth * shift );
|
||||
};
|
||||
|
||||
proto.remove = function() {
|
||||
this.element.parentNode.removeChild( this.element );
|
||||
};
|
||||
|
||||
return Cell;
|
||||
|
||||
}));
|
||||
393
node_modules/flickity/js/drag.js
generated
vendored
Normal file
393
node_modules/flickity/js/drag.js
generated
vendored
Normal file
@@ -0,0 +1,393 @@
|
||||
// drag
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'./flickity',
|
||||
'unidragger/unidragger',
|
||||
'fizzy-ui-utils/utils'
|
||||
], function( Flickity, Unidragger, utils ) {
|
||||
return factory( window, Flickity, Unidragger, utils );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('./flickity'),
|
||||
require('unidragger'),
|
||||
require('fizzy-ui-utils')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
window.Flickity = factory(
|
||||
window,
|
||||
window.Flickity,
|
||||
window.Unidragger,
|
||||
window.fizzyUIUtils
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, Flickity, Unidragger, utils ) {
|
||||
|
||||
'use strict';
|
||||
|
||||
// ----- defaults ----- //
|
||||
|
||||
utils.extend( Flickity.defaults, {
|
||||
draggable: '>1',
|
||||
dragThreshold: 3,
|
||||
});
|
||||
|
||||
// ----- create ----- //
|
||||
|
||||
Flickity.createMethods.push('_createDrag');
|
||||
|
||||
// -------------------------- drag prototype -------------------------- //
|
||||
|
||||
var proto = Flickity.prototype;
|
||||
utils.extend( proto, Unidragger.prototype );
|
||||
proto._touchActionValue = 'pan-y';
|
||||
|
||||
// -------------------------- -------------------------- //
|
||||
|
||||
var isTouch = 'createTouch' in document;
|
||||
var isTouchmoveScrollCanceled = false;
|
||||
|
||||
proto._createDrag = function() {
|
||||
this.on( 'activate', this.onActivateDrag );
|
||||
this.on( 'uiChange', this._uiChangeDrag );
|
||||
this.on( 'deactivate', this.onDeactivateDrag );
|
||||
this.on( 'cellChange', this.updateDraggable );
|
||||
// TODO updateDraggable on resize? if groupCells & slides change
|
||||
// HACK - add seemingly innocuous handler to fix iOS 10 scroll behavior
|
||||
// #457, RubaXa/Sortable#973
|
||||
if ( isTouch && !isTouchmoveScrollCanceled ) {
|
||||
window.addEventListener( 'touchmove', function() {});
|
||||
isTouchmoveScrollCanceled = true;
|
||||
}
|
||||
};
|
||||
|
||||
proto.onActivateDrag = function() {
|
||||
this.handles = [ this.viewport ];
|
||||
this.bindHandles();
|
||||
this.updateDraggable();
|
||||
};
|
||||
|
||||
proto.onDeactivateDrag = function() {
|
||||
this.unbindHandles();
|
||||
this.element.classList.remove('is-draggable');
|
||||
};
|
||||
|
||||
proto.updateDraggable = function() {
|
||||
// disable dragging if less than 2 slides. #278
|
||||
if ( this.options.draggable == '>1' ) {
|
||||
this.isDraggable = this.slides.length > 1;
|
||||
} else {
|
||||
this.isDraggable = this.options.draggable;
|
||||
}
|
||||
if ( this.isDraggable ) {
|
||||
this.element.classList.add('is-draggable');
|
||||
} else {
|
||||
this.element.classList.remove('is-draggable');
|
||||
}
|
||||
};
|
||||
|
||||
// backwards compatibility
|
||||
proto.bindDrag = function() {
|
||||
this.options.draggable = true;
|
||||
this.updateDraggable();
|
||||
};
|
||||
|
||||
proto.unbindDrag = function() {
|
||||
this.options.draggable = false;
|
||||
this.updateDraggable();
|
||||
};
|
||||
|
||||
proto._uiChangeDrag = function() {
|
||||
delete this.isFreeScrolling;
|
||||
};
|
||||
|
||||
// -------------------------- pointer events -------------------------- //
|
||||
|
||||
proto.pointerDown = function( event, pointer ) {
|
||||
if ( !this.isDraggable ) {
|
||||
this._pointerDownDefault( event, pointer );
|
||||
return;
|
||||
}
|
||||
var isOkay = this.okayPointerDown( event );
|
||||
if ( !isOkay ) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._pointerDownPreventDefault( event );
|
||||
this.pointerDownFocus( event );
|
||||
// blur
|
||||
if ( document.activeElement != this.element ) {
|
||||
// do not blur if already focused
|
||||
this.pointerDownBlur();
|
||||
}
|
||||
|
||||
// stop if it was moving
|
||||
this.dragX = this.x;
|
||||
this.viewport.classList.add('is-pointer-down');
|
||||
// track scrolling
|
||||
this.pointerDownScroll = getScrollPosition();
|
||||
window.addEventListener( 'scroll', this );
|
||||
|
||||
this._pointerDownDefault( event, pointer );
|
||||
};
|
||||
|
||||
// default pointerDown logic, used for staticClick
|
||||
proto._pointerDownDefault = function( event, pointer ) {
|
||||
// track start event position
|
||||
// Safari 9 overrides pageX and pageY. These values needs to be copied. #779
|
||||
this.pointerDownPointer = {
|
||||
pageX: pointer.pageX,
|
||||
pageY: pointer.pageY,
|
||||
};
|
||||
// bind move and end events
|
||||
this._bindPostStartEvents( event );
|
||||
this.dispatchEvent( 'pointerDown', event, [ pointer ] );
|
||||
};
|
||||
|
||||
var focusNodes = {
|
||||
INPUT: true,
|
||||
TEXTAREA: true,
|
||||
SELECT: true,
|
||||
};
|
||||
|
||||
proto.pointerDownFocus = function( event ) {
|
||||
var isFocusNode = focusNodes[ event.target.nodeName ];
|
||||
if ( !isFocusNode ) {
|
||||
this.focus();
|
||||
}
|
||||
};
|
||||
|
||||
proto._pointerDownPreventDefault = function( event ) {
|
||||
var isTouchStart = event.type == 'touchstart';
|
||||
var isTouchPointer = event.pointerType == 'touch';
|
||||
var isFocusNode = focusNodes[ event.target.nodeName ];
|
||||
if ( !isTouchStart && !isTouchPointer && !isFocusNode ) {
|
||||
event.preventDefault();
|
||||
}
|
||||
};
|
||||
|
||||
// ----- move ----- //
|
||||
|
||||
proto.hasDragStarted = function( moveVector ) {
|
||||
return Math.abs( moveVector.x ) > this.options.dragThreshold;
|
||||
};
|
||||
|
||||
// ----- up ----- //
|
||||
|
||||
proto.pointerUp = function( event, pointer ) {
|
||||
delete this.isTouchScrolling;
|
||||
this.viewport.classList.remove('is-pointer-down');
|
||||
this.dispatchEvent( 'pointerUp', event, [ pointer ] );
|
||||
this._dragPointerUp( event, pointer );
|
||||
};
|
||||
|
||||
proto.pointerDone = function() {
|
||||
window.removeEventListener( 'scroll', this );
|
||||
delete this.pointerDownScroll;
|
||||
};
|
||||
|
||||
// -------------------------- dragging -------------------------- //
|
||||
|
||||
proto.dragStart = function( event, pointer ) {
|
||||
if ( !this.isDraggable ) {
|
||||
return;
|
||||
}
|
||||
this.dragStartPosition = this.x;
|
||||
this.startAnimation();
|
||||
window.removeEventListener( 'scroll', this );
|
||||
this.dispatchEvent( 'dragStart', event, [ pointer ] );
|
||||
};
|
||||
|
||||
proto.pointerMove = function( event, pointer ) {
|
||||
var moveVector = this._dragPointerMove( event, pointer );
|
||||
this.dispatchEvent( 'pointerMove', event, [ pointer, moveVector ] );
|
||||
this._dragMove( event, pointer, moveVector );
|
||||
};
|
||||
|
||||
proto.dragMove = function( event, pointer, moveVector ) {
|
||||
if ( !this.isDraggable ) {
|
||||
return;
|
||||
}
|
||||
event.preventDefault();
|
||||
|
||||
this.previousDragX = this.dragX;
|
||||
// reverse if right-to-left
|
||||
var direction = this.options.rightToLeft ? -1 : 1;
|
||||
if ( this.options.wrapAround ) {
|
||||
// wrap around move. #589
|
||||
moveVector.x = moveVector.x % this.slideableWidth;
|
||||
}
|
||||
var dragX = this.dragStartPosition + moveVector.x * direction;
|
||||
|
||||
if ( !this.options.wrapAround && this.slides.length ) {
|
||||
// slow drag
|
||||
var originBound = Math.max( -this.slides[0].target, this.dragStartPosition );
|
||||
dragX = dragX > originBound ? ( dragX + originBound ) * 0.5 : dragX;
|
||||
var endBound = Math.min( -this.getLastSlide().target, this.dragStartPosition );
|
||||
dragX = dragX < endBound ? ( dragX + endBound ) * 0.5 : dragX;
|
||||
}
|
||||
|
||||
this.dragX = dragX;
|
||||
|
||||
this.dragMoveTime = new Date();
|
||||
this.dispatchEvent( 'dragMove', event, [ pointer, moveVector ] );
|
||||
};
|
||||
|
||||
proto.dragEnd = function( event, pointer ) {
|
||||
if ( !this.isDraggable ) {
|
||||
return;
|
||||
}
|
||||
if ( this.options.freeScroll ) {
|
||||
this.isFreeScrolling = true;
|
||||
}
|
||||
// set selectedIndex based on where flick will end up
|
||||
var index = this.dragEndRestingSelect();
|
||||
|
||||
if ( this.options.freeScroll && !this.options.wrapAround ) {
|
||||
// if free-scroll & not wrap around
|
||||
// do not free-scroll if going outside of bounding slides
|
||||
// so bounding slides can attract slider, and keep it in bounds
|
||||
var restingX = this.getRestingPosition();
|
||||
this.isFreeScrolling = -restingX > this.slides[0].target &&
|
||||
-restingX < this.getLastSlide().target;
|
||||
} else if ( !this.options.freeScroll && index == this.selectedIndex ) {
|
||||
// boost selection if selected index has not changed
|
||||
index += this.dragEndBoostSelect();
|
||||
}
|
||||
delete this.previousDragX;
|
||||
// apply selection
|
||||
// TODO refactor this, selecting here feels weird
|
||||
// HACK, set flag so dragging stays in correct direction
|
||||
this.isDragSelect = this.options.wrapAround;
|
||||
this.select( index );
|
||||
delete this.isDragSelect;
|
||||
this.dispatchEvent( 'dragEnd', event, [ pointer ] );
|
||||
};
|
||||
|
||||
proto.dragEndRestingSelect = function() {
|
||||
var restingX = this.getRestingPosition();
|
||||
// how far away from selected slide
|
||||
var distance = Math.abs( this.getSlideDistance( -restingX, this.selectedIndex ) );
|
||||
// get closet resting going up and going down
|
||||
var positiveResting = this._getClosestResting( restingX, distance, 1 );
|
||||
var negativeResting = this._getClosestResting( restingX, distance, -1 );
|
||||
// use closer resting for wrap-around
|
||||
var index = positiveResting.distance < negativeResting.distance ?
|
||||
positiveResting.index : negativeResting.index;
|
||||
return index;
|
||||
};
|
||||
|
||||
/**
|
||||
* given resting X and distance to selected cell
|
||||
* get the distance and index of the closest cell
|
||||
* @param {Number} restingX - estimated post-flick resting position
|
||||
* @param {Number} distance - distance to selected cell
|
||||
* @param {Integer} increment - +1 or -1, going up or down
|
||||
* @returns {Object} - { distance: {Number}, index: {Integer} }
|
||||
*/
|
||||
proto._getClosestResting = function( restingX, distance, increment ) {
|
||||
var index = this.selectedIndex;
|
||||
var minDistance = Infinity;
|
||||
var condition = this.options.contain && !this.options.wrapAround ?
|
||||
// if contain, keep going if distance is equal to minDistance
|
||||
function( d, md ) { return d <= md; } : function( d, md ) { return d < md; };
|
||||
while ( condition( distance, minDistance ) ) {
|
||||
// measure distance to next cell
|
||||
index += increment;
|
||||
minDistance = distance;
|
||||
distance = this.getSlideDistance( -restingX, index );
|
||||
if ( distance === null ) {
|
||||
break;
|
||||
}
|
||||
distance = Math.abs( distance );
|
||||
}
|
||||
return {
|
||||
distance: minDistance,
|
||||
// selected was previous index
|
||||
index: index - increment
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* measure distance between x and a slide target
|
||||
* @param {Number} x
|
||||
* @param {Integer} index - slide index
|
||||
*/
|
||||
proto.getSlideDistance = function( x, index ) {
|
||||
var len = this.slides.length;
|
||||
// wrap around if at least 2 slides
|
||||
var isWrapAround = this.options.wrapAround && len > 1;
|
||||
var slideIndex = isWrapAround ? utils.modulo( index, len ) : index;
|
||||
var slide = this.slides[ slideIndex ];
|
||||
if ( !slide ) {
|
||||
return null;
|
||||
}
|
||||
// add distance for wrap-around slides
|
||||
var wrap = isWrapAround ? this.slideableWidth * Math.floor( index / len ) : 0;
|
||||
return x - ( slide.target + wrap );
|
||||
};
|
||||
|
||||
proto.dragEndBoostSelect = function() {
|
||||
// do not boost if no previousDragX or dragMoveTime
|
||||
if ( this.previousDragX === undefined || !this.dragMoveTime ||
|
||||
// or if drag was held for 100 ms
|
||||
new Date() - this.dragMoveTime > 100 ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
var distance = this.getSlideDistance( -this.dragX, this.selectedIndex );
|
||||
var delta = this.previousDragX - this.dragX;
|
||||
if ( distance > 0 && delta > 0 ) {
|
||||
// boost to next if moving towards the right, and positive velocity
|
||||
return 1;
|
||||
} else if ( distance < 0 && delta < 0 ) {
|
||||
// boost to previous if moving towards the left, and negative velocity
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
};
|
||||
|
||||
// ----- staticClick ----- //
|
||||
|
||||
proto.staticClick = function( event, pointer ) {
|
||||
// get clickedCell, if cell was clicked
|
||||
var clickedCell = this.getParentCell( event.target );
|
||||
var cellElem = clickedCell && clickedCell.element;
|
||||
var cellIndex = clickedCell && this.cells.indexOf( clickedCell );
|
||||
this.dispatchEvent( 'staticClick', event, [ pointer, cellElem, cellIndex ] );
|
||||
};
|
||||
|
||||
// ----- scroll ----- //
|
||||
|
||||
proto.onscroll = function() {
|
||||
var scroll = getScrollPosition();
|
||||
var scrollMoveX = this.pointerDownScroll.x - scroll.x;
|
||||
var scrollMoveY = this.pointerDownScroll.y - scroll.y;
|
||||
// cancel click/tap if scroll is too much
|
||||
if ( Math.abs( scrollMoveX ) > 3 || Math.abs( scrollMoveY ) > 3 ) {
|
||||
this._pointerDone();
|
||||
}
|
||||
};
|
||||
|
||||
// ----- utils ----- //
|
||||
|
||||
function getScrollPosition() {
|
||||
return {
|
||||
x: window.pageXOffset,
|
||||
y: window.pageYOffset
|
||||
};
|
||||
}
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
929
node_modules/flickity/js/flickity.js
generated
vendored
Normal file
929
node_modules/flickity/js/flickity.js
generated
vendored
Normal file
@@ -0,0 +1,929 @@
|
||||
// Flickity main
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'ev-emitter/ev-emitter',
|
||||
'get-size/get-size',
|
||||
'fizzy-ui-utils/utils',
|
||||
'./cell',
|
||||
'./slide',
|
||||
'./animate'
|
||||
], function( EvEmitter, getSize, utils, Cell, Slide, animatePrototype ) {
|
||||
return factory( window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('ev-emitter'),
|
||||
require('get-size'),
|
||||
require('fizzy-ui-utils'),
|
||||
require('./cell'),
|
||||
require('./slide'),
|
||||
require('./animate')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
var _Flickity = window.Flickity;
|
||||
|
||||
window.Flickity = factory(
|
||||
window,
|
||||
window.EvEmitter,
|
||||
window.getSize,
|
||||
window.fizzyUIUtils,
|
||||
_Flickity.Cell,
|
||||
_Flickity.Slide,
|
||||
_Flickity.animatePrototype
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, EvEmitter, getSize,
|
||||
utils, Cell, Slide, animatePrototype ) {
|
||||
|
||||
'use strict';
|
||||
|
||||
// vars
|
||||
var jQuery = window.jQuery;
|
||||
var getComputedStyle = window.getComputedStyle;
|
||||
var console = window.console;
|
||||
|
||||
function moveElements( elems, toElem ) {
|
||||
elems = utils.makeArray( elems );
|
||||
while ( elems.length ) {
|
||||
toElem.appendChild( elems.shift() );
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------- Flickity -------------------------- //
|
||||
|
||||
// globally unique identifiers
|
||||
var GUID = 0;
|
||||
// internal store of all Flickity intances
|
||||
var instances = {};
|
||||
|
||||
function Flickity( element, options ) {
|
||||
var queryElement = utils.getQueryElement( element );
|
||||
if ( !queryElement ) {
|
||||
if ( console ) {
|
||||
console.error( 'Bad element for Flickity: ' + ( queryElement || element ) );
|
||||
}
|
||||
return;
|
||||
}
|
||||
this.element = queryElement;
|
||||
// do not initialize twice on same element
|
||||
if ( this.element.flickityGUID ) {
|
||||
var instance = instances[ this.element.flickityGUID ];
|
||||
instance.option( options );
|
||||
return instance;
|
||||
}
|
||||
|
||||
// add jQuery
|
||||
if ( jQuery ) {
|
||||
this.$element = jQuery( this.element );
|
||||
}
|
||||
// options
|
||||
this.options = utils.extend( {}, this.constructor.defaults );
|
||||
this.option( options );
|
||||
|
||||
// kick things off
|
||||
this._create();
|
||||
}
|
||||
|
||||
Flickity.defaults = {
|
||||
accessibility: true,
|
||||
// adaptiveHeight: false,
|
||||
cellAlign: 'center',
|
||||
// cellSelector: undefined,
|
||||
// contain: false,
|
||||
freeScrollFriction: 0.075, // friction when free-scrolling
|
||||
friction: 0.28, // friction when selecting
|
||||
namespaceJQueryEvents: true,
|
||||
// initialIndex: 0,
|
||||
percentPosition: true,
|
||||
resize: true,
|
||||
selectedAttraction: 0.025,
|
||||
setGallerySize: true
|
||||
// watchCSS: false,
|
||||
// wrapAround: false
|
||||
};
|
||||
|
||||
// hash of methods triggered on _create()
|
||||
Flickity.createMethods = [];
|
||||
|
||||
var proto = Flickity.prototype;
|
||||
// inherit EventEmitter
|
||||
utils.extend( proto, EvEmitter.prototype );
|
||||
|
||||
proto._create = function() {
|
||||
// add id for Flickity.data
|
||||
var id = this.guid = ++GUID;
|
||||
this.element.flickityGUID = id; // expando
|
||||
instances[ id ] = this; // associate via id
|
||||
// initial properties
|
||||
this.selectedIndex = 0;
|
||||
// how many frames slider has been in same position
|
||||
this.restingFrames = 0;
|
||||
// initial physics properties
|
||||
this.x = 0;
|
||||
this.velocity = 0;
|
||||
this.originSide = this.options.rightToLeft ? 'right' : 'left';
|
||||
// create viewport & slider
|
||||
this.viewport = document.createElement('div');
|
||||
this.viewport.className = 'flickity-viewport';
|
||||
this._createSlider();
|
||||
|
||||
if ( this.options.resize || this.options.watchCSS ) {
|
||||
window.addEventListener( 'resize', this );
|
||||
}
|
||||
|
||||
// add listeners from on option
|
||||
for ( var eventName in this.options.on ) {
|
||||
var listener = this.options.on[ eventName ];
|
||||
this.on( eventName, listener );
|
||||
}
|
||||
|
||||
Flickity.createMethods.forEach( function( method ) {
|
||||
this[ method ]();
|
||||
}, this );
|
||||
|
||||
if ( this.options.watchCSS ) {
|
||||
this.watchCSS();
|
||||
} else {
|
||||
this.activate();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
* set options
|
||||
* @param {Object} opts
|
||||
*/
|
||||
proto.option = function( opts ) {
|
||||
utils.extend( this.options, opts );
|
||||
};
|
||||
|
||||
proto.activate = function() {
|
||||
if ( this.isActive ) {
|
||||
return;
|
||||
}
|
||||
this.isActive = true;
|
||||
this.element.classList.add('flickity-enabled');
|
||||
if ( this.options.rightToLeft ) {
|
||||
this.element.classList.add('flickity-rtl');
|
||||
}
|
||||
|
||||
this.getSize();
|
||||
// move initial cell elements so they can be loaded as cells
|
||||
var cellElems = this._filterFindCellElements( this.element.children );
|
||||
moveElements( cellElems, this.slider );
|
||||
this.viewport.appendChild( this.slider );
|
||||
this.element.appendChild( this.viewport );
|
||||
// get cells from children
|
||||
this.reloadCells();
|
||||
|
||||
if ( this.options.accessibility ) {
|
||||
// allow element to focusable
|
||||
this.element.tabIndex = 0;
|
||||
// listen for key presses
|
||||
this.element.addEventListener( 'keydown', this );
|
||||
}
|
||||
|
||||
this.emitEvent('activate');
|
||||
this.selectInitialIndex();
|
||||
// flag for initial activation, for using initialIndex
|
||||
this.isInitActivated = true;
|
||||
// ready event. #493
|
||||
this.dispatchEvent('ready');
|
||||
};
|
||||
|
||||
// slider positions the cells
|
||||
proto._createSlider = function() {
|
||||
// slider element does all the positioning
|
||||
var slider = document.createElement('div');
|
||||
slider.className = 'flickity-slider';
|
||||
slider.style[ this.originSide ] = 0;
|
||||
this.slider = slider;
|
||||
};
|
||||
|
||||
proto._filterFindCellElements = function( elems ) {
|
||||
return utils.filterFindElements( elems, this.options.cellSelector );
|
||||
};
|
||||
|
||||
// goes through all children
|
||||
proto.reloadCells = function() {
|
||||
// collection of item elements
|
||||
this.cells = this._makeCells( this.slider.children );
|
||||
this.positionCells();
|
||||
this._getWrapShiftCells();
|
||||
this.setGallerySize();
|
||||
};
|
||||
|
||||
/**
|
||||
* turn elements into Flickity.Cells
|
||||
* @param {Array or NodeList or HTMLElement} elems
|
||||
* @returns {Array} items - collection of new Flickity Cells
|
||||
*/
|
||||
proto._makeCells = function( elems ) {
|
||||
var cellElems = this._filterFindCellElements( elems );
|
||||
|
||||
// create new Flickity for collection
|
||||
var cells = cellElems.map( function( cellElem ) {
|
||||
return new Cell( cellElem, this );
|
||||
}, this );
|
||||
|
||||
return cells;
|
||||
};
|
||||
|
||||
proto.getLastCell = function() {
|
||||
return this.cells[ this.cells.length - 1 ];
|
||||
};
|
||||
|
||||
proto.getLastSlide = function() {
|
||||
return this.slides[ this.slides.length - 1 ];
|
||||
};
|
||||
|
||||
// positions all cells
|
||||
proto.positionCells = function() {
|
||||
// size all cells
|
||||
this._sizeCells( this.cells );
|
||||
// position all cells
|
||||
this._positionCells( 0 );
|
||||
};
|
||||
|
||||
/**
|
||||
* position certain cells
|
||||
* @param {Integer} index - which cell to start with
|
||||
*/
|
||||
proto._positionCells = function( index ) {
|
||||
index = index || 0;
|
||||
// also measure maxCellHeight
|
||||
// start 0 if positioning all cells
|
||||
this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;
|
||||
var cellX = 0;
|
||||
// get cellX
|
||||
if ( index > 0 ) {
|
||||
var startCell = this.cells[ index - 1 ];
|
||||
cellX = startCell.x + startCell.size.outerWidth;
|
||||
}
|
||||
var len = this.cells.length;
|
||||
for ( var i=index; i < len; i++ ) {
|
||||
var cell = this.cells[i];
|
||||
cell.setPosition( cellX );
|
||||
cellX += cell.size.outerWidth;
|
||||
this.maxCellHeight = Math.max( cell.size.outerHeight, this.maxCellHeight );
|
||||
}
|
||||
// keep track of cellX for wrap-around
|
||||
this.slideableWidth = cellX;
|
||||
// slides
|
||||
this.updateSlides();
|
||||
// contain slides target
|
||||
this._containSlides();
|
||||
// update slidesWidth
|
||||
this.slidesWidth = len ? this.getLastSlide().target - this.slides[0].target : 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* cell.getSize() on multiple cells
|
||||
* @param {Array} cells
|
||||
*/
|
||||
proto._sizeCells = function( cells ) {
|
||||
cells.forEach( function( cell ) {
|
||||
cell.getSize();
|
||||
});
|
||||
};
|
||||
|
||||
// -------------------------- -------------------------- //
|
||||
|
||||
proto.updateSlides = function() {
|
||||
this.slides = [];
|
||||
if ( !this.cells.length ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var slide = new Slide( this );
|
||||
this.slides.push( slide );
|
||||
var isOriginLeft = this.originSide == 'left';
|
||||
var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';
|
||||
|
||||
var canCellFit = this._getCanCellFit();
|
||||
|
||||
this.cells.forEach( function( cell, i ) {
|
||||
// just add cell if first cell in slide
|
||||
if ( !slide.cells.length ) {
|
||||
slide.addCell( cell );
|
||||
return;
|
||||
}
|
||||
|
||||
var slideWidth = ( slide.outerWidth - slide.firstMargin ) +
|
||||
( cell.size.outerWidth - cell.size[ nextMargin ] );
|
||||
|
||||
if ( canCellFit.call( this, i, slideWidth ) ) {
|
||||
slide.addCell( cell );
|
||||
} else {
|
||||
// doesn't fit, new slide
|
||||
slide.updateTarget();
|
||||
|
||||
slide = new Slide( this );
|
||||
this.slides.push( slide );
|
||||
slide.addCell( cell );
|
||||
}
|
||||
}, this );
|
||||
// last slide
|
||||
slide.updateTarget();
|
||||
// update .selectedSlide
|
||||
this.updateSelectedSlide();
|
||||
};
|
||||
|
||||
proto._getCanCellFit = function() {
|
||||
var groupCells = this.options.groupCells;
|
||||
if ( !groupCells ) {
|
||||
return function() {
|
||||
return false;
|
||||
};
|
||||
} else if ( typeof groupCells == 'number' ) {
|
||||
// group by number. 3 -> [0,1,2], [3,4,5], ...
|
||||
var number = parseInt( groupCells, 10 );
|
||||
return function( i ) {
|
||||
return ( i % number ) !== 0;
|
||||
};
|
||||
}
|
||||
// default, group by width of slide
|
||||
// parse '75%
|
||||
var percentMatch = typeof groupCells == 'string' &&
|
||||
groupCells.match(/^(\d+)%$/);
|
||||
var percent = percentMatch ? parseInt( percentMatch[1], 10 ) / 100 : 1;
|
||||
return function( i, slideWidth ) {
|
||||
return slideWidth <= ( this.size.innerWidth + 1 ) * percent;
|
||||
};
|
||||
};
|
||||
|
||||
// alias _init for jQuery plugin .flickity()
|
||||
proto._init =
|
||||
proto.reposition = function() {
|
||||
this.positionCells();
|
||||
this.positionSliderAtSelected();
|
||||
};
|
||||
|
||||
proto.getSize = function() {
|
||||
this.size = getSize( this.element );
|
||||
this.setCellAlign();
|
||||
this.cursorPosition = this.size.innerWidth * this.cellAlign;
|
||||
};
|
||||
|
||||
var cellAlignShorthands = {
|
||||
// cell align, then based on origin side
|
||||
center: {
|
||||
left: 0.5,
|
||||
right: 0.5
|
||||
},
|
||||
left: {
|
||||
left: 0,
|
||||
right: 1
|
||||
},
|
||||
right: {
|
||||
right: 0,
|
||||
left: 1
|
||||
}
|
||||
};
|
||||
|
||||
proto.setCellAlign = function() {
|
||||
var shorthand = cellAlignShorthands[ this.options.cellAlign ];
|
||||
this.cellAlign = shorthand ? shorthand[ this.originSide ] : this.options.cellAlign;
|
||||
};
|
||||
|
||||
proto.setGallerySize = function() {
|
||||
if ( this.options.setGallerySize ) {
|
||||
var height = this.options.adaptiveHeight && this.selectedSlide ?
|
||||
this.selectedSlide.height : this.maxCellHeight;
|
||||
this.viewport.style.height = height + 'px';
|
||||
}
|
||||
};
|
||||
|
||||
proto._getWrapShiftCells = function() {
|
||||
// only for wrap-around
|
||||
if ( !this.options.wrapAround ) {
|
||||
return;
|
||||
}
|
||||
// unshift previous cells
|
||||
this._unshiftCells( this.beforeShiftCells );
|
||||
this._unshiftCells( this.afterShiftCells );
|
||||
// get before cells
|
||||
// initial gap
|
||||
var gapX = this.cursorPosition;
|
||||
var cellIndex = this.cells.length - 1;
|
||||
this.beforeShiftCells = this._getGapCells( gapX, cellIndex, -1 );
|
||||
// get after cells
|
||||
// ending gap between last cell and end of gallery viewport
|
||||
gapX = this.size.innerWidth - this.cursorPosition;
|
||||
// start cloning at first cell, working forwards
|
||||
this.afterShiftCells = this._getGapCells( gapX, 0, 1 );
|
||||
};
|
||||
|
||||
proto._getGapCells = function( gapX, cellIndex, increment ) {
|
||||
// keep adding cells until the cover the initial gap
|
||||
var cells = [];
|
||||
while ( gapX > 0 ) {
|
||||
var cell = this.cells[ cellIndex ];
|
||||
if ( !cell ) {
|
||||
break;
|
||||
}
|
||||
cells.push( cell );
|
||||
cellIndex += increment;
|
||||
gapX -= cell.size.outerWidth;
|
||||
}
|
||||
return cells;
|
||||
};
|
||||
|
||||
// ----- contain ----- //
|
||||
|
||||
// contain cell targets so no excess sliding
|
||||
proto._containSlides = function() {
|
||||
if ( !this.options.contain || this.options.wrapAround || !this.cells.length ) {
|
||||
return;
|
||||
}
|
||||
var isRightToLeft = this.options.rightToLeft;
|
||||
var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
|
||||
var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
|
||||
var contentWidth = this.slideableWidth - this.getLastCell().size[ endMargin ];
|
||||
// content is less than gallery size
|
||||
var isContentSmaller = contentWidth < this.size.innerWidth;
|
||||
// bounds
|
||||
var beginBound = this.cursorPosition + this.cells[0].size[ beginMargin ];
|
||||
var endBound = contentWidth - this.size.innerWidth * ( 1 - this.cellAlign );
|
||||
// contain each cell target
|
||||
this.slides.forEach( function( slide ) {
|
||||
if ( isContentSmaller ) {
|
||||
// all cells fit inside gallery
|
||||
slide.target = contentWidth * this.cellAlign;
|
||||
} else {
|
||||
// contain to bounds
|
||||
slide.target = Math.max( slide.target, beginBound );
|
||||
slide.target = Math.min( slide.target, endBound );
|
||||
}
|
||||
}, this );
|
||||
};
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
/**
|
||||
* emits events via eventEmitter and jQuery events
|
||||
* @param {String} type - name of event
|
||||
* @param {Event} event - original event
|
||||
* @param {Array} args - extra arguments
|
||||
*/
|
||||
proto.dispatchEvent = function( type, event, args ) {
|
||||
var emitArgs = event ? [ event ].concat( args ) : args;
|
||||
this.emitEvent( type, emitArgs );
|
||||
|
||||
if ( jQuery && this.$element ) {
|
||||
// default trigger with type if no event
|
||||
type += this.options.namespaceJQueryEvents ? '.flickity' : '';
|
||||
var $event = type;
|
||||
if ( event ) {
|
||||
// create jQuery event
|
||||
var jQEvent = jQuery.Event( event );
|
||||
jQEvent.type = type;
|
||||
$event = jQEvent;
|
||||
}
|
||||
this.$element.trigger( $event, args );
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------- select -------------------------- //
|
||||
|
||||
/**
|
||||
* @param {Integer} index - index of the slide
|
||||
* @param {Boolean} isWrap - will wrap-around to last/first if at the end
|
||||
* @param {Boolean} isInstant - will immediately set position at selected cell
|
||||
*/
|
||||
proto.select = function( index, isWrap, isInstant ) {
|
||||
if ( !this.isActive ) {
|
||||
return;
|
||||
}
|
||||
index = parseInt( index, 10 );
|
||||
this._wrapSelect( index );
|
||||
|
||||
if ( this.options.wrapAround || isWrap ) {
|
||||
index = utils.modulo( index, this.slides.length );
|
||||
}
|
||||
// bail if invalid index
|
||||
if ( !this.slides[ index ] ) {
|
||||
return;
|
||||
}
|
||||
var prevIndex = this.selectedIndex;
|
||||
this.selectedIndex = index;
|
||||
this.updateSelectedSlide();
|
||||
if ( isInstant ) {
|
||||
this.positionSliderAtSelected();
|
||||
} else {
|
||||
this.startAnimation();
|
||||
}
|
||||
if ( this.options.adaptiveHeight ) {
|
||||
this.setGallerySize();
|
||||
}
|
||||
// events
|
||||
this.dispatchEvent( 'select', null, [ index ] );
|
||||
// change event if new index
|
||||
if ( index != prevIndex ) {
|
||||
this.dispatchEvent( 'change', null, [ index ] );
|
||||
}
|
||||
// old v1 event name, remove in v3
|
||||
this.dispatchEvent('cellSelect');
|
||||
};
|
||||
|
||||
// wraps position for wrapAround, to move to closest slide. #113
|
||||
proto._wrapSelect = function( index ) {
|
||||
var len = this.slides.length;
|
||||
var isWrapping = this.options.wrapAround && len > 1;
|
||||
if ( !isWrapping ) {
|
||||
return index;
|
||||
}
|
||||
var wrapIndex = utils.modulo( index, len );
|
||||
// go to shortest
|
||||
var delta = Math.abs( wrapIndex - this.selectedIndex );
|
||||
var backWrapDelta = Math.abs( ( wrapIndex + len ) - this.selectedIndex );
|
||||
var forewardWrapDelta = Math.abs( ( wrapIndex - len ) - this.selectedIndex );
|
||||
if ( !this.isDragSelect && backWrapDelta < delta ) {
|
||||
index += len;
|
||||
} else if ( !this.isDragSelect && forewardWrapDelta < delta ) {
|
||||
index -= len;
|
||||
}
|
||||
// wrap position so slider is within normal area
|
||||
if ( index < 0 ) {
|
||||
this.x -= this.slideableWidth;
|
||||
} else if ( index >= len ) {
|
||||
this.x += this.slideableWidth;
|
||||
}
|
||||
};
|
||||
|
||||
proto.previous = function( isWrap, isInstant ) {
|
||||
this.select( this.selectedIndex - 1, isWrap, isInstant );
|
||||
};
|
||||
|
||||
proto.next = function( isWrap, isInstant ) {
|
||||
this.select( this.selectedIndex + 1, isWrap, isInstant );
|
||||
};
|
||||
|
||||
proto.updateSelectedSlide = function() {
|
||||
var slide = this.slides[ this.selectedIndex ];
|
||||
// selectedIndex could be outside of slides, if triggered before resize()
|
||||
if ( !slide ) {
|
||||
return;
|
||||
}
|
||||
// unselect previous selected slide
|
||||
this.unselectSelectedSlide();
|
||||
// update new selected slide
|
||||
this.selectedSlide = slide;
|
||||
slide.select();
|
||||
this.selectedCells = slide.cells;
|
||||
this.selectedElements = slide.getCellElements();
|
||||
// HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility
|
||||
// Remove in v3?
|
||||
this.selectedCell = slide.cells[0];
|
||||
this.selectedElement = this.selectedElements[0];
|
||||
};
|
||||
|
||||
proto.unselectSelectedSlide = function() {
|
||||
if ( this.selectedSlide ) {
|
||||
this.selectedSlide.unselect();
|
||||
}
|
||||
};
|
||||
|
||||
proto.selectInitialIndex = function() {
|
||||
var initialIndex = this.options.initialIndex;
|
||||
// already activated, select previous selectedIndex
|
||||
if ( this.isInitActivated ) {
|
||||
this.select( this.selectedIndex, false, true );
|
||||
return;
|
||||
}
|
||||
// select with selector string
|
||||
if ( initialIndex && typeof initialIndex == 'string' ) {
|
||||
var cell = this.queryCell( initialIndex );
|
||||
if ( cell ) {
|
||||
this.selectCell( initialIndex, false, true );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
var index = 0;
|
||||
// select with number
|
||||
if ( initialIndex && this.slides[ initialIndex ] ) {
|
||||
index = initialIndex;
|
||||
}
|
||||
// select instantly
|
||||
this.select( index, false, true );
|
||||
};
|
||||
|
||||
/**
|
||||
* select slide from number or cell element
|
||||
* @param {Element or Number} elem
|
||||
*/
|
||||
proto.selectCell = function( value, isWrap, isInstant ) {
|
||||
// get cell
|
||||
var cell = this.queryCell( value );
|
||||
if ( !cell ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var index = this.getCellSlideIndex( cell );
|
||||
this.select( index, isWrap, isInstant );
|
||||
};
|
||||
|
||||
proto.getCellSlideIndex = function( cell ) {
|
||||
// get index of slides that has cell
|
||||
for ( var i=0; i < this.slides.length; i++ ) {
|
||||
var slide = this.slides[i];
|
||||
var index = slide.cells.indexOf( cell );
|
||||
if ( index != -1 ) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------- get cells -------------------------- //
|
||||
|
||||
/**
|
||||
* get Flickity.Cell, given an Element
|
||||
* @param {Element} elem
|
||||
* @returns {Flickity.Cell} item
|
||||
*/
|
||||
proto.getCell = function( elem ) {
|
||||
// loop through cells to get the one that matches
|
||||
for ( var i=0; i < this.cells.length; i++ ) {
|
||||
var cell = this.cells[i];
|
||||
if ( cell.element == elem ) {
|
||||
return cell;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* get collection of Flickity.Cells, given Elements
|
||||
* @param {Element, Array, NodeList} elems
|
||||
* @returns {Array} cells - Flickity.Cells
|
||||
*/
|
||||
proto.getCells = function( elems ) {
|
||||
elems = utils.makeArray( elems );
|
||||
var cells = [];
|
||||
elems.forEach( function( elem ) {
|
||||
var cell = this.getCell( elem );
|
||||
if ( cell ) {
|
||||
cells.push( cell );
|
||||
}
|
||||
}, this );
|
||||
return cells;
|
||||
};
|
||||
|
||||
/**
|
||||
* get cell elements
|
||||
* @returns {Array} cellElems
|
||||
*/
|
||||
proto.getCellElements = function() {
|
||||
return this.cells.map( function( cell ) {
|
||||
return cell.element;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* get parent cell from an element
|
||||
* @param {Element} elem
|
||||
* @returns {Flickit.Cell} cell
|
||||
*/
|
||||
proto.getParentCell = function( elem ) {
|
||||
// first check if elem is cell
|
||||
var cell = this.getCell( elem );
|
||||
if ( cell ) {
|
||||
return cell;
|
||||
}
|
||||
// try to get parent cell elem
|
||||
elem = utils.getParent( elem, '.flickity-slider > *' );
|
||||
return this.getCell( elem );
|
||||
};
|
||||
|
||||
/**
|
||||
* get cells adjacent to a slide
|
||||
* @param {Integer} adjCount - number of adjacent slides
|
||||
* @param {Integer} index - index of slide to start
|
||||
* @returns {Array} cells - array of Flickity.Cells
|
||||
*/
|
||||
proto.getAdjacentCellElements = function( adjCount, index ) {
|
||||
if ( !adjCount ) {
|
||||
return this.selectedSlide.getCellElements();
|
||||
}
|
||||
index = index === undefined ? this.selectedIndex : index;
|
||||
|
||||
var len = this.slides.length;
|
||||
if ( 1 + ( adjCount * 2 ) >= len ) {
|
||||
return this.getCellElements();
|
||||
}
|
||||
|
||||
var cellElems = [];
|
||||
for ( var i = index - adjCount; i <= index + adjCount ; i++ ) {
|
||||
var slideIndex = this.options.wrapAround ? utils.modulo( i, len ) : i;
|
||||
var slide = this.slides[ slideIndex ];
|
||||
if ( slide ) {
|
||||
cellElems = cellElems.concat( slide.getCellElements() );
|
||||
}
|
||||
}
|
||||
return cellElems;
|
||||
};
|
||||
|
||||
/**
|
||||
* select slide from number or cell element
|
||||
* @param {Element, Selector String, or Number} selector
|
||||
*/
|
||||
proto.queryCell = function( selector ) {
|
||||
if ( typeof selector == 'number' ) {
|
||||
// use number as index
|
||||
return this.cells[ selector ];
|
||||
}
|
||||
if ( typeof selector == 'string' ) {
|
||||
// do not select invalid selectors from hash: #123, #/. #791
|
||||
if ( selector.match(/^[#\.]?[\d\/]/) ) {
|
||||
return;
|
||||
}
|
||||
// use string as selector, get element
|
||||
selector = this.element.querySelector( selector );
|
||||
}
|
||||
// get cell from element
|
||||
return this.getCell( selector );
|
||||
};
|
||||
|
||||
// -------------------------- events -------------------------- //
|
||||
|
||||
proto.uiChange = function() {
|
||||
this.emitEvent('uiChange');
|
||||
};
|
||||
|
||||
// keep focus on element when child UI elements are clicked
|
||||
proto.childUIPointerDown = function( event ) {
|
||||
// HACK iOS does not allow touch events to bubble up?!
|
||||
if ( event.type != 'touchstart' ) {
|
||||
event.preventDefault();
|
||||
}
|
||||
this.focus();
|
||||
};
|
||||
|
||||
// ----- resize ----- //
|
||||
|
||||
proto.onresize = function() {
|
||||
this.watchCSS();
|
||||
this.resize();
|
||||
};
|
||||
|
||||
utils.debounceMethod( Flickity, 'onresize', 150 );
|
||||
|
||||
proto.resize = function() {
|
||||
if ( !this.isActive ) {
|
||||
return;
|
||||
}
|
||||
this.getSize();
|
||||
// wrap values
|
||||
if ( this.options.wrapAround ) {
|
||||
this.x = utils.modulo( this.x, this.slideableWidth );
|
||||
}
|
||||
this.positionCells();
|
||||
this._getWrapShiftCells();
|
||||
this.setGallerySize();
|
||||
this.emitEvent('resize');
|
||||
// update selected index for group slides, instant
|
||||
// TODO: position can be lost between groups of various numbers
|
||||
var selectedElement = this.selectedElements && this.selectedElements[0];
|
||||
this.selectCell( selectedElement, false, true );
|
||||
};
|
||||
|
||||
// watches the :after property, activates/deactivates
|
||||
proto.watchCSS = function() {
|
||||
var watchOption = this.options.watchCSS;
|
||||
if ( !watchOption ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var afterContent = getComputedStyle( this.element, ':after' ).content;
|
||||
// activate if :after { content: 'flickity' }
|
||||
if ( afterContent.indexOf('flickity') != -1 ) {
|
||||
this.activate();
|
||||
} else {
|
||||
this.deactivate();
|
||||
}
|
||||
};
|
||||
|
||||
// ----- keydown ----- //
|
||||
|
||||
// go previous/next if left/right keys pressed
|
||||
proto.onkeydown = function( event ) {
|
||||
// only work if element is in focus
|
||||
var isNotFocused = document.activeElement && document.activeElement != this.element;
|
||||
if ( !this.options.accessibility ||isNotFocused ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var handler = Flickity.keyboardHandlers[ event.keyCode ];
|
||||
if ( handler ) {
|
||||
handler.call( this );
|
||||
}
|
||||
};
|
||||
|
||||
Flickity.keyboardHandlers = {
|
||||
// left arrow
|
||||
37: function() {
|
||||
var leftMethod = this.options.rightToLeft ? 'next' : 'previous';
|
||||
this.uiChange();
|
||||
this[ leftMethod ]();
|
||||
},
|
||||
// right arrow
|
||||
39: function() {
|
||||
var rightMethod = this.options.rightToLeft ? 'previous' : 'next';
|
||||
this.uiChange();
|
||||
this[ rightMethod ]();
|
||||
},
|
||||
};
|
||||
|
||||
// ----- focus ----- //
|
||||
|
||||
proto.focus = function() {
|
||||
// TODO remove scrollTo once focus options gets more support
|
||||
// https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#Browser_compatibility
|
||||
var prevScrollY = window.pageYOffset;
|
||||
this.element.focus({ preventScroll: true });
|
||||
// hack to fix scroll jump after focus, #76
|
||||
if ( window.pageYOffset != prevScrollY ) {
|
||||
window.scrollTo( window.pageXOffset, prevScrollY );
|
||||
}
|
||||
};
|
||||
|
||||
// -------------------------- destroy -------------------------- //
|
||||
|
||||
// deactivate all Flickity functionality, but keep stuff available
|
||||
proto.deactivate = function() {
|
||||
if ( !this.isActive ) {
|
||||
return;
|
||||
}
|
||||
this.element.classList.remove('flickity-enabled');
|
||||
this.element.classList.remove('flickity-rtl');
|
||||
this.unselectSelectedSlide();
|
||||
// destroy cells
|
||||
this.cells.forEach( function( cell ) {
|
||||
cell.destroy();
|
||||
});
|
||||
this.element.removeChild( this.viewport );
|
||||
// move child elements back into element
|
||||
moveElements( this.slider.children, this.element );
|
||||
if ( this.options.accessibility ) {
|
||||
this.element.removeAttribute('tabIndex');
|
||||
this.element.removeEventListener( 'keydown', this );
|
||||
}
|
||||
// set flags
|
||||
this.isActive = false;
|
||||
this.emitEvent('deactivate');
|
||||
};
|
||||
|
||||
proto.destroy = function() {
|
||||
this.deactivate();
|
||||
window.removeEventListener( 'resize', this );
|
||||
this.allOff();
|
||||
this.emitEvent('destroy');
|
||||
if ( jQuery && this.$element ) {
|
||||
jQuery.removeData( this.element, 'flickity' );
|
||||
}
|
||||
delete this.element.flickityGUID;
|
||||
delete instances[ this.guid ];
|
||||
};
|
||||
|
||||
// -------------------------- prototype -------------------------- //
|
||||
|
||||
utils.extend( proto, animatePrototype );
|
||||
|
||||
// -------------------------- extras -------------------------- //
|
||||
|
||||
/**
|
||||
* get Flickity instance from element
|
||||
* @param {Element} elem
|
||||
* @returns {Flickity}
|
||||
*/
|
||||
Flickity.data = function( elem ) {
|
||||
elem = utils.getQueryElement( elem );
|
||||
var id = elem && elem.flickityGUID;
|
||||
return id && instances[ id ];
|
||||
};
|
||||
|
||||
utils.htmlInit( Flickity, 'flickity' );
|
||||
|
||||
if ( jQuery && jQuery.bridget ) {
|
||||
jQuery.bridget( 'flickity', Flickity );
|
||||
}
|
||||
|
||||
// set internal jQuery, for Webpack + jQuery v3, #478
|
||||
Flickity.setJQuery = function( jq ) {
|
||||
jQuery = jq;
|
||||
};
|
||||
|
||||
Flickity.Cell = Cell;
|
||||
Flickity.Slide = Slide;
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
42
node_modules/flickity/js/index.js
generated
vendored
Normal file
42
node_modules/flickity/js/index.js
generated
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
/*!
|
||||
* Flickity v2.2.1
|
||||
* Touch, responsive, flickable carousels
|
||||
*
|
||||
* Licensed GPLv3 for open source use
|
||||
* or Flickity Commercial License for commercial use
|
||||
*
|
||||
* https://flickity.metafizzy.co
|
||||
* Copyright 2015-2019 Metafizzy
|
||||
*/
|
||||
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'./flickity',
|
||||
'./drag',
|
||||
'./prev-next-button',
|
||||
'./page-dots',
|
||||
'./player',
|
||||
'./add-remove-cell',
|
||||
'./lazyload'
|
||||
], factory );
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
require('./flickity'),
|
||||
require('./drag'),
|
||||
require('./prev-next-button'),
|
||||
require('./page-dots'),
|
||||
require('./player'),
|
||||
require('./add-remove-cell'),
|
||||
require('./lazyload')
|
||||
);
|
||||
}
|
||||
|
||||
})( window, function factory( Flickity ) {
|
||||
/*jshint strict: false*/
|
||||
return Flickity;
|
||||
});
|
||||
134
node_modules/flickity/js/lazyload.js
generated
vendored
Normal file
134
node_modules/flickity/js/lazyload.js
generated
vendored
Normal file
@@ -0,0 +1,134 @@
|
||||
// lazyload
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'./flickity',
|
||||
'fizzy-ui-utils/utils'
|
||||
], function( Flickity, utils ) {
|
||||
return factory( window, Flickity, utils );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('./flickity'),
|
||||
require('fizzy-ui-utils')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
factory(
|
||||
window,
|
||||
window.Flickity,
|
||||
window.fizzyUIUtils
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, Flickity, utils ) {
|
||||
'use strict';
|
||||
|
||||
Flickity.createMethods.push('_createLazyload');
|
||||
var proto = Flickity.prototype;
|
||||
|
||||
proto._createLazyload = function() {
|
||||
this.on( 'select', this.lazyLoad );
|
||||
};
|
||||
|
||||
proto.lazyLoad = function() {
|
||||
var lazyLoad = this.options.lazyLoad;
|
||||
if ( !lazyLoad ) {
|
||||
return;
|
||||
}
|
||||
// get adjacent cells, use lazyLoad option for adjacent count
|
||||
var adjCount = typeof lazyLoad == 'number' ? lazyLoad : 0;
|
||||
var cellElems = this.getAdjacentCellElements( adjCount );
|
||||
// get lazy images in those cells
|
||||
var lazyImages = [];
|
||||
cellElems.forEach( function( cellElem ) {
|
||||
var lazyCellImages = getCellLazyImages( cellElem );
|
||||
lazyImages = lazyImages.concat( lazyCellImages );
|
||||
});
|
||||
// load lazy images
|
||||
lazyImages.forEach( function( img ) {
|
||||
new LazyLoader( img, this );
|
||||
}, this );
|
||||
};
|
||||
|
||||
function getCellLazyImages( cellElem ) {
|
||||
// check if cell element is lazy image
|
||||
if ( cellElem.nodeName == 'IMG' ) {
|
||||
var lazyloadAttr = cellElem.getAttribute('data-flickity-lazyload');
|
||||
var srcAttr = cellElem.getAttribute('data-flickity-lazyload-src');
|
||||
var srcsetAttr = cellElem.getAttribute('data-flickity-lazyload-srcset');
|
||||
if ( lazyloadAttr || srcAttr || srcsetAttr ) {
|
||||
return [ cellElem ];
|
||||
}
|
||||
}
|
||||
// select lazy images in cell
|
||||
var lazySelector = 'img[data-flickity-lazyload], ' +
|
||||
'img[data-flickity-lazyload-src], img[data-flickity-lazyload-srcset]';
|
||||
var imgs = cellElem.querySelectorAll( lazySelector );
|
||||
return utils.makeArray( imgs );
|
||||
}
|
||||
|
||||
// -------------------------- LazyLoader -------------------------- //
|
||||
|
||||
/**
|
||||
* class to handle loading images
|
||||
*/
|
||||
function LazyLoader( img, flickity ) {
|
||||
this.img = img;
|
||||
this.flickity = flickity;
|
||||
this.load();
|
||||
}
|
||||
|
||||
LazyLoader.prototype.handleEvent = utils.handleEvent;
|
||||
|
||||
LazyLoader.prototype.load = function() {
|
||||
this.img.addEventListener( 'load', this );
|
||||
this.img.addEventListener( 'error', this );
|
||||
// get src & srcset
|
||||
var src = this.img.getAttribute('data-flickity-lazyload') ||
|
||||
this.img.getAttribute('data-flickity-lazyload-src');
|
||||
var srcset = this.img.getAttribute('data-flickity-lazyload-srcset');
|
||||
// set src & serset
|
||||
this.img.src = src;
|
||||
if ( srcset ) {
|
||||
this.img.setAttribute( 'srcset', srcset );
|
||||
}
|
||||
// remove attr
|
||||
this.img.removeAttribute('data-flickity-lazyload');
|
||||
this.img.removeAttribute('data-flickity-lazyload-src');
|
||||
this.img.removeAttribute('data-flickity-lazyload-srcset');
|
||||
};
|
||||
|
||||
LazyLoader.prototype.onload = function( event ) {
|
||||
this.complete( event, 'flickity-lazyloaded' );
|
||||
};
|
||||
|
||||
LazyLoader.prototype.onerror = function( event ) {
|
||||
this.complete( event, 'flickity-lazyerror' );
|
||||
};
|
||||
|
||||
LazyLoader.prototype.complete = function( event, className ) {
|
||||
// unbind events
|
||||
this.img.removeEventListener( 'load', this );
|
||||
this.img.removeEventListener( 'error', this );
|
||||
|
||||
var cell = this.flickity.getParentCell( this.img );
|
||||
var cellElem = cell && cell.element;
|
||||
this.flickity.cellSizeChange( cellElem );
|
||||
|
||||
this.img.classList.add( className );
|
||||
this.flickity.dispatchEvent( 'lazyLoad', event, cellElem );
|
||||
};
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
Flickity.LazyLoader = LazyLoader;
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
188
node_modules/flickity/js/page-dots.js
generated
vendored
Normal file
188
node_modules/flickity/js/page-dots.js
generated
vendored
Normal file
@@ -0,0 +1,188 @@
|
||||
// page dots
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'./flickity',
|
||||
'unipointer/unipointer',
|
||||
'fizzy-ui-utils/utils'
|
||||
], function( Flickity, Unipointer, utils ) {
|
||||
return factory( window, Flickity, Unipointer, utils );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('./flickity'),
|
||||
require('unipointer'),
|
||||
require('fizzy-ui-utils')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
factory(
|
||||
window,
|
||||
window.Flickity,
|
||||
window.Unipointer,
|
||||
window.fizzyUIUtils
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, Flickity, Unipointer, utils ) {
|
||||
|
||||
// -------------------------- PageDots -------------------------- //
|
||||
|
||||
'use strict';
|
||||
|
||||
function PageDots( parent ) {
|
||||
this.parent = parent;
|
||||
this._create();
|
||||
}
|
||||
|
||||
PageDots.prototype = Object.create( Unipointer.prototype );
|
||||
|
||||
PageDots.prototype._create = function() {
|
||||
// create holder element
|
||||
this.holder = document.createElement('ol');
|
||||
this.holder.className = 'flickity-page-dots';
|
||||
// create dots, array of elements
|
||||
this.dots = [];
|
||||
// events
|
||||
this.handleClick = this.onClick.bind( this );
|
||||
this.on( 'pointerDown', this.parent.childUIPointerDown.bind( this.parent ) );
|
||||
};
|
||||
|
||||
PageDots.prototype.activate = function() {
|
||||
this.setDots();
|
||||
this.holder.addEventListener( 'click', this.handleClick );
|
||||
this.bindStartEvent( this.holder );
|
||||
// add to DOM
|
||||
this.parent.element.appendChild( this.holder );
|
||||
};
|
||||
|
||||
PageDots.prototype.deactivate = function() {
|
||||
this.holder.removeEventListener( 'click', this.handleClick );
|
||||
this.unbindStartEvent( this.holder );
|
||||
// remove from DOM
|
||||
this.parent.element.removeChild( this.holder );
|
||||
};
|
||||
|
||||
PageDots.prototype.setDots = function() {
|
||||
// get difference between number of slides and number of dots
|
||||
var delta = this.parent.slides.length - this.dots.length;
|
||||
if ( delta > 0 ) {
|
||||
this.addDots( delta );
|
||||
} else if ( delta < 0 ) {
|
||||
this.removeDots( -delta );
|
||||
}
|
||||
};
|
||||
|
||||
PageDots.prototype.addDots = function( count ) {
|
||||
var fragment = document.createDocumentFragment();
|
||||
var newDots = [];
|
||||
var length = this.dots.length;
|
||||
var max = length + count;
|
||||
|
||||
for ( var i = length; i < max; i++ ) {
|
||||
var dot = document.createElement('li');
|
||||
dot.className = 'dot';
|
||||
dot.setAttribute( 'aria-label', 'Page dot ' + ( i + 1 ) );
|
||||
fragment.appendChild( dot );
|
||||
newDots.push( dot );
|
||||
}
|
||||
|
||||
this.holder.appendChild( fragment );
|
||||
this.dots = this.dots.concat( newDots );
|
||||
};
|
||||
|
||||
PageDots.prototype.removeDots = function( count ) {
|
||||
// remove from this.dots collection
|
||||
var removeDots = this.dots.splice( this.dots.length - count, count );
|
||||
// remove from DOM
|
||||
removeDots.forEach( function( dot ) {
|
||||
this.holder.removeChild( dot );
|
||||
}, this );
|
||||
};
|
||||
|
||||
PageDots.prototype.updateSelected = function() {
|
||||
// remove selected class on previous
|
||||
if ( this.selectedDot ) {
|
||||
this.selectedDot.className = 'dot';
|
||||
this.selectedDot.removeAttribute('aria-current');
|
||||
}
|
||||
// don't proceed if no dots
|
||||
if ( !this.dots.length ) {
|
||||
return;
|
||||
}
|
||||
this.selectedDot = this.dots[ this.parent.selectedIndex ];
|
||||
this.selectedDot.className = 'dot is-selected';
|
||||
this.selectedDot.setAttribute( 'aria-current', 'step' );
|
||||
};
|
||||
|
||||
PageDots.prototype.onTap = // old method name, backwards-compatible
|
||||
PageDots.prototype.onClick = function( event ) {
|
||||
var target = event.target;
|
||||
// only care about dot clicks
|
||||
if ( target.nodeName != 'LI' ) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.parent.uiChange();
|
||||
var index = this.dots.indexOf( target );
|
||||
this.parent.select( index );
|
||||
};
|
||||
|
||||
PageDots.prototype.destroy = function() {
|
||||
this.deactivate();
|
||||
this.allOff();
|
||||
};
|
||||
|
||||
Flickity.PageDots = PageDots;
|
||||
|
||||
// -------------------------- Flickity -------------------------- //
|
||||
|
||||
utils.extend( Flickity.defaults, {
|
||||
pageDots: true
|
||||
});
|
||||
|
||||
Flickity.createMethods.push('_createPageDots');
|
||||
|
||||
var proto = Flickity.prototype;
|
||||
|
||||
proto._createPageDots = function() {
|
||||
if ( !this.options.pageDots ) {
|
||||
return;
|
||||
}
|
||||
this.pageDots = new PageDots( this );
|
||||
// events
|
||||
this.on( 'activate', this.activatePageDots );
|
||||
this.on( 'select', this.updateSelectedPageDots );
|
||||
this.on( 'cellChange', this.updatePageDots );
|
||||
this.on( 'resize', this.updatePageDots );
|
||||
this.on( 'deactivate', this.deactivatePageDots );
|
||||
};
|
||||
|
||||
proto.activatePageDots = function() {
|
||||
this.pageDots.activate();
|
||||
};
|
||||
|
||||
proto.updateSelectedPageDots = function() {
|
||||
this.pageDots.updateSelected();
|
||||
};
|
||||
|
||||
proto.updatePageDots = function() {
|
||||
this.pageDots.setDots();
|
||||
};
|
||||
|
||||
proto.deactivatePageDots = function() {
|
||||
this.pageDots.deactivate();
|
||||
};
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
Flickity.PageDots = PageDots;
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
191
node_modules/flickity/js/player.js
generated
vendored
Normal file
191
node_modules/flickity/js/player.js
generated
vendored
Normal file
@@ -0,0 +1,191 @@
|
||||
// player & autoPlay
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'ev-emitter/ev-emitter',
|
||||
'fizzy-ui-utils/utils',
|
||||
'./flickity'
|
||||
], function( EvEmitter, utils, Flickity ) {
|
||||
return factory( EvEmitter, utils, Flickity );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
require('ev-emitter'),
|
||||
require('fizzy-ui-utils'),
|
||||
require('./flickity')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
factory(
|
||||
window.EvEmitter,
|
||||
window.fizzyUIUtils,
|
||||
window.Flickity
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( EvEmitter, utils, Flickity ) {
|
||||
|
||||
'use strict';
|
||||
|
||||
// -------------------------- Player -------------------------- //
|
||||
|
||||
function Player( parent ) {
|
||||
this.parent = parent;
|
||||
this.state = 'stopped';
|
||||
// visibility change event handler
|
||||
this.onVisibilityChange = this.visibilityChange.bind( this );
|
||||
this.onVisibilityPlay = this.visibilityPlay.bind( this );
|
||||
}
|
||||
|
||||
Player.prototype = Object.create( EvEmitter.prototype );
|
||||
|
||||
// start play
|
||||
Player.prototype.play = function() {
|
||||
if ( this.state == 'playing' ) {
|
||||
return;
|
||||
}
|
||||
// do not play if page is hidden, start playing when page is visible
|
||||
var isPageHidden = document.hidden;
|
||||
if ( isPageHidden ) {
|
||||
document.addEventListener( 'visibilitychange', this.onVisibilityPlay );
|
||||
return;
|
||||
}
|
||||
|
||||
this.state = 'playing';
|
||||
// listen to visibility change
|
||||
document.addEventListener( 'visibilitychange', this.onVisibilityChange );
|
||||
// start ticking
|
||||
this.tick();
|
||||
};
|
||||
|
||||
Player.prototype.tick = function() {
|
||||
// do not tick if not playing
|
||||
if ( this.state != 'playing' ) {
|
||||
return;
|
||||
}
|
||||
|
||||
var time = this.parent.options.autoPlay;
|
||||
// default to 3 seconds
|
||||
time = typeof time == 'number' ? time : 3000;
|
||||
var _this = this;
|
||||
// HACK: reset ticks if stopped and started within interval
|
||||
this.clear();
|
||||
this.timeout = setTimeout( function() {
|
||||
_this.parent.next( true );
|
||||
_this.tick();
|
||||
}, time );
|
||||
};
|
||||
|
||||
Player.prototype.stop = function() {
|
||||
this.state = 'stopped';
|
||||
this.clear();
|
||||
// remove visibility change event
|
||||
document.removeEventListener( 'visibilitychange', this.onVisibilityChange );
|
||||
};
|
||||
|
||||
Player.prototype.clear = function() {
|
||||
clearTimeout( this.timeout );
|
||||
};
|
||||
|
||||
Player.prototype.pause = function() {
|
||||
if ( this.state == 'playing' ) {
|
||||
this.state = 'paused';
|
||||
this.clear();
|
||||
}
|
||||
};
|
||||
|
||||
Player.prototype.unpause = function() {
|
||||
// re-start play if paused
|
||||
if ( this.state == 'paused' ) {
|
||||
this.play();
|
||||
}
|
||||
};
|
||||
|
||||
// pause if page visibility is hidden, unpause if visible
|
||||
Player.prototype.visibilityChange = function() {
|
||||
var isPageHidden = document.hidden;
|
||||
this[ isPageHidden ? 'pause' : 'unpause' ]();
|
||||
};
|
||||
|
||||
Player.prototype.visibilityPlay = function() {
|
||||
this.play();
|
||||
document.removeEventListener( 'visibilitychange', this.onVisibilityPlay );
|
||||
};
|
||||
|
||||
// -------------------------- Flickity -------------------------- //
|
||||
|
||||
utils.extend( Flickity.defaults, {
|
||||
pauseAutoPlayOnHover: true
|
||||
});
|
||||
|
||||
Flickity.createMethods.push('_createPlayer');
|
||||
var proto = Flickity.prototype;
|
||||
|
||||
proto._createPlayer = function() {
|
||||
this.player = new Player( this );
|
||||
|
||||
this.on( 'activate', this.activatePlayer );
|
||||
this.on( 'uiChange', this.stopPlayer );
|
||||
this.on( 'pointerDown', this.stopPlayer );
|
||||
this.on( 'deactivate', this.deactivatePlayer );
|
||||
};
|
||||
|
||||
proto.activatePlayer = function() {
|
||||
if ( !this.options.autoPlay ) {
|
||||
return;
|
||||
}
|
||||
this.player.play();
|
||||
this.element.addEventListener( 'mouseenter', this );
|
||||
};
|
||||
|
||||
// Player API, don't hate the ... thanks I know where the door is
|
||||
|
||||
proto.playPlayer = function() {
|
||||
this.player.play();
|
||||
};
|
||||
|
||||
proto.stopPlayer = function() {
|
||||
this.player.stop();
|
||||
};
|
||||
|
||||
proto.pausePlayer = function() {
|
||||
this.player.pause();
|
||||
};
|
||||
|
||||
proto.unpausePlayer = function() {
|
||||
this.player.unpause();
|
||||
};
|
||||
|
||||
proto.deactivatePlayer = function() {
|
||||
this.player.stop();
|
||||
this.element.removeEventListener( 'mouseenter', this );
|
||||
};
|
||||
|
||||
// ----- mouseenter/leave ----- //
|
||||
|
||||
// pause auto-play on hover
|
||||
proto.onmouseenter = function() {
|
||||
if ( !this.options.pauseAutoPlayOnHover ) {
|
||||
return;
|
||||
}
|
||||
this.player.pause();
|
||||
this.element.addEventListener( 'mouseleave', this );
|
||||
};
|
||||
|
||||
// resume auto-play on hover off
|
||||
proto.onmouseleave = function() {
|
||||
this.player.unpause();
|
||||
this.element.removeEventListener( 'mouseleave', this );
|
||||
};
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
Flickity.Player = Player;
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
211
node_modules/flickity/js/prev-next-button.js
generated
vendored
Normal file
211
node_modules/flickity/js/prev-next-button.js
generated
vendored
Normal file
@@ -0,0 +1,211 @@
|
||||
// prev/next buttons
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( [
|
||||
'./flickity',
|
||||
'unipointer/unipointer',
|
||||
'fizzy-ui-utils/utils'
|
||||
], function( Flickity, Unipointer, utils ) {
|
||||
return factory( window, Flickity, Unipointer, utils );
|
||||
});
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory(
|
||||
window,
|
||||
require('./flickity'),
|
||||
require('unipointer'),
|
||||
require('fizzy-ui-utils')
|
||||
);
|
||||
} else {
|
||||
// browser global
|
||||
factory(
|
||||
window,
|
||||
window.Flickity,
|
||||
window.Unipointer,
|
||||
window.fizzyUIUtils
|
||||
);
|
||||
}
|
||||
|
||||
}( window, function factory( window, Flickity, Unipointer, utils ) {
|
||||
'use strict';
|
||||
|
||||
var svgURI = 'http://www.w3.org/2000/svg';
|
||||
|
||||
// -------------------------- PrevNextButton -------------------------- //
|
||||
|
||||
function PrevNextButton( direction, parent ) {
|
||||
this.direction = direction;
|
||||
this.parent = parent;
|
||||
this._create();
|
||||
}
|
||||
|
||||
PrevNextButton.prototype = Object.create( Unipointer.prototype );
|
||||
|
||||
PrevNextButton.prototype._create = function() {
|
||||
// properties
|
||||
this.isEnabled = true;
|
||||
this.isPrevious = this.direction == -1;
|
||||
var leftDirection = this.parent.options.rightToLeft ? 1 : -1;
|
||||
this.isLeft = this.direction == leftDirection;
|
||||
|
||||
var element = this.element = document.createElement('button');
|
||||
element.className = 'flickity-button flickity-prev-next-button';
|
||||
element.className += this.isPrevious ? ' previous' : ' next';
|
||||
// prevent button from submitting form http://stackoverflow.com/a/10836076/182183
|
||||
element.setAttribute( 'type', 'button' );
|
||||
// init as disabled
|
||||
this.disable();
|
||||
|
||||
element.setAttribute( 'aria-label', this.isPrevious ? 'Previous' : 'Next' );
|
||||
|
||||
// create arrow
|
||||
var svg = this.createSVG();
|
||||
element.appendChild( svg );
|
||||
// events
|
||||
this.parent.on( 'select', this.update.bind( this ) );
|
||||
this.on( 'pointerDown', this.parent.childUIPointerDown.bind( this.parent ) );
|
||||
};
|
||||
|
||||
PrevNextButton.prototype.activate = function() {
|
||||
this.bindStartEvent( this.element );
|
||||
this.element.addEventListener( 'click', this );
|
||||
// add to DOM
|
||||
this.parent.element.appendChild( this.element );
|
||||
};
|
||||
|
||||
PrevNextButton.prototype.deactivate = function() {
|
||||
// remove from DOM
|
||||
this.parent.element.removeChild( this.element );
|
||||
// click events
|
||||
this.unbindStartEvent( this.element );
|
||||
this.element.removeEventListener( 'click', this );
|
||||
};
|
||||
|
||||
PrevNextButton.prototype.createSVG = function() {
|
||||
var svg = document.createElementNS( svgURI, 'svg');
|
||||
svg.setAttribute( 'class', 'flickity-button-icon' );
|
||||
svg.setAttribute( 'viewBox', '0 0 100 100' );
|
||||
var path = document.createElementNS( svgURI, 'path');
|
||||
var pathMovements = getArrowMovements( this.parent.options.arrowShape );
|
||||
path.setAttribute( 'd', pathMovements );
|
||||
path.setAttribute( 'class', 'arrow' );
|
||||
// rotate arrow
|
||||
if ( !this.isLeft ) {
|
||||
path.setAttribute( 'transform', 'translate(100, 100) rotate(180) ' );
|
||||
}
|
||||
svg.appendChild( path );
|
||||
return svg;
|
||||
};
|
||||
|
||||
// get SVG path movmement
|
||||
function getArrowMovements( shape ) {
|
||||
// use shape as movement if string
|
||||
if ( typeof shape == 'string' ) {
|
||||
return shape;
|
||||
}
|
||||
// create movement string
|
||||
return 'M ' + shape.x0 + ',50' +
|
||||
' L ' + shape.x1 + ',' + ( shape.y1 + 50 ) +
|
||||
' L ' + shape.x2 + ',' + ( shape.y2 + 50 ) +
|
||||
' L ' + shape.x3 + ',50 ' +
|
||||
' L ' + shape.x2 + ',' + ( 50 - shape.y2 ) +
|
||||
' L ' + shape.x1 + ',' + ( 50 - shape.y1 ) +
|
||||
' Z';
|
||||
}
|
||||
|
||||
PrevNextButton.prototype.handleEvent = utils.handleEvent;
|
||||
|
||||
PrevNextButton.prototype.onclick = function() {
|
||||
if ( !this.isEnabled ) {
|
||||
return;
|
||||
}
|
||||
this.parent.uiChange();
|
||||
var method = this.isPrevious ? 'previous' : 'next';
|
||||
this.parent[ method ]();
|
||||
};
|
||||
|
||||
// ----- ----- //
|
||||
|
||||
PrevNextButton.prototype.enable = function() {
|
||||
if ( this.isEnabled ) {
|
||||
return;
|
||||
}
|
||||
this.element.disabled = false;
|
||||
this.isEnabled = true;
|
||||
};
|
||||
|
||||
PrevNextButton.prototype.disable = function() {
|
||||
if ( !this.isEnabled ) {
|
||||
return;
|
||||
}
|
||||
this.element.disabled = true;
|
||||
this.isEnabled = false;
|
||||
};
|
||||
|
||||
PrevNextButton.prototype.update = function() {
|
||||
// index of first or last slide, if previous or next
|
||||
var slides = this.parent.slides;
|
||||
// enable is wrapAround and at least 2 slides
|
||||
if ( this.parent.options.wrapAround && slides.length > 1 ) {
|
||||
this.enable();
|
||||
return;
|
||||
}
|
||||
var lastIndex = slides.length ? slides.length - 1 : 0;
|
||||
var boundIndex = this.isPrevious ? 0 : lastIndex;
|
||||
var method = this.parent.selectedIndex == boundIndex ? 'disable' : 'enable';
|
||||
this[ method ]();
|
||||
};
|
||||
|
||||
PrevNextButton.prototype.destroy = function() {
|
||||
this.deactivate();
|
||||
this.allOff();
|
||||
};
|
||||
|
||||
// -------------------------- Flickity prototype -------------------------- //
|
||||
|
||||
utils.extend( Flickity.defaults, {
|
||||
prevNextButtons: true,
|
||||
arrowShape: {
|
||||
x0: 10,
|
||||
x1: 60, y1: 50,
|
||||
x2: 70, y2: 40,
|
||||
x3: 30
|
||||
}
|
||||
});
|
||||
|
||||
Flickity.createMethods.push('_createPrevNextButtons');
|
||||
var proto = Flickity.prototype;
|
||||
|
||||
proto._createPrevNextButtons = function() {
|
||||
if ( !this.options.prevNextButtons ) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.prevButton = new PrevNextButton( -1, this );
|
||||
this.nextButton = new PrevNextButton( 1, this );
|
||||
|
||||
this.on( 'activate', this.activatePrevNextButtons );
|
||||
};
|
||||
|
||||
proto.activatePrevNextButtons = function() {
|
||||
this.prevButton.activate();
|
||||
this.nextButton.activate();
|
||||
this.on( 'deactivate', this.deactivatePrevNextButtons );
|
||||
};
|
||||
|
||||
proto.deactivatePrevNextButtons = function() {
|
||||
this.prevButton.deactivate();
|
||||
this.nextButton.deactivate();
|
||||
this.off( 'deactivate', this.deactivatePrevNextButtons );
|
||||
};
|
||||
|
||||
// -------------------------- -------------------------- //
|
||||
|
||||
Flickity.PrevNextButton = PrevNextButton;
|
||||
|
||||
return Flickity;
|
||||
|
||||
}));
|
||||
74
node_modules/flickity/js/slide.js
generated
vendored
Normal file
74
node_modules/flickity/js/slide.js
generated
vendored
Normal file
@@ -0,0 +1,74 @@
|
||||
// slide
|
||||
( function( window, factory ) {
|
||||
// universal module definition
|
||||
/* jshint strict: false */
|
||||
if ( typeof define == 'function' && define.amd ) {
|
||||
// AMD
|
||||
define( factory );
|
||||
} else if ( typeof module == 'object' && module.exports ) {
|
||||
// CommonJS
|
||||
module.exports = factory();
|
||||
} else {
|
||||
// browser global
|
||||
window.Flickity = window.Flickity || {};
|
||||
window.Flickity.Slide = factory();
|
||||
}
|
||||
|
||||
}( window, function factory() {
|
||||
'use strict';
|
||||
|
||||
function Slide( parent ) {
|
||||
this.parent = parent;
|
||||
this.isOriginLeft = parent.originSide == 'left';
|
||||
this.cells = [];
|
||||
this.outerWidth = 0;
|
||||
this.height = 0;
|
||||
}
|
||||
|
||||
var proto = Slide.prototype;
|
||||
|
||||
proto.addCell = function( cell ) {
|
||||
this.cells.push( cell );
|
||||
this.outerWidth += cell.size.outerWidth;
|
||||
this.height = Math.max( cell.size.outerHeight, this.height );
|
||||
// first cell stuff
|
||||
if ( this.cells.length == 1 ) {
|
||||
this.x = cell.x; // x comes from first cell
|
||||
var beginMargin = this.isOriginLeft ? 'marginLeft' : 'marginRight';
|
||||
this.firstMargin = cell.size[ beginMargin ];
|
||||
}
|
||||
};
|
||||
|
||||
proto.updateTarget = function() {
|
||||
var endMargin = this.isOriginLeft ? 'marginRight' : 'marginLeft';
|
||||
var lastCell = this.getLastCell();
|
||||
var lastMargin = lastCell ? lastCell.size[ endMargin ] : 0;
|
||||
var slideWidth = this.outerWidth - ( this.firstMargin + lastMargin );
|
||||
this.target = this.x + this.firstMargin + slideWidth * this.parent.cellAlign;
|
||||
};
|
||||
|
||||
proto.getLastCell = function() {
|
||||
return this.cells[ this.cells.length - 1 ];
|
||||
};
|
||||
|
||||
proto.select = function() {
|
||||
this.cells.forEach( function( cell ) {
|
||||
cell.select();
|
||||
});
|
||||
};
|
||||
|
||||
proto.unselect = function() {
|
||||
this.cells.forEach( function( cell ) {
|
||||
cell.unselect();
|
||||
});
|
||||
};
|
||||
|
||||
proto.getCellElements = function() {
|
||||
return this.cells.map( function( cell ) {
|
||||
return cell.element;
|
||||
});
|
||||
};
|
||||
|
||||
return Slide;
|
||||
|
||||
}));
|
||||
Reference in New Issue
Block a user