diff --git a/assets/scripts/App.js b/assets/scripts/App.js index 59e8bf6..eaecc7e 100644 --- a/assets/scripts/App.js +++ b/assets/scripts/App.js @@ -1,5 +1,5 @@ /* jshint esnext: true */ -import { APP_NAME, $document, $barba } from './utils/environment'; +import { APP_NAME, $document, $pjaxWrapper } from './utils/environment'; import globals from './globals'; @@ -106,8 +106,8 @@ class App { $moduleEls = $document.find('[data-module]'); } else if (event.$scope instanceof jQuery && event.$scope.length > 0) { $moduleEls = event.$scope.find('[data-module]'); - } else if (event.isBarba) { - $moduleEls = $barba.find('[data-module]'); + } else if (event.isPjax) { + $moduleEls = $pjaxWrapper.find('[data-module]'); } // Loop through elements diff --git a/assets/scripts/modules/Example.js b/assets/scripts/modules/Example.js index 7c404af..dc24a96 100644 --- a/assets/scripts/modules/Example.js +++ b/assets/scripts/modules/Example.js @@ -14,13 +14,17 @@ export default class extends AbstractModule { super(options); // Declaration of properties + console.log('πŸ”¨ [module]:constructor - Example'); + } init() { // Set events and such + } destroy() { + console.log('❌ [module]:destroy - Example'); super.destroy(); this.$el.off(`.${EVENT_NAMESPACE}`); } diff --git a/assets/scripts/transitions/BaseTransition.js b/assets/scripts/transitions/BaseTransition.js new file mode 100644 index 0000000..f2a1057 --- /dev/null +++ b/assets/scripts/transitions/BaseTransition.js @@ -0,0 +1,82 @@ +import { APP_NAME, $document, $html, $body, isDebug, $pjaxWrapper } from '../utils/environment'; + +const MODULE_NAME = 'Transition'; +const EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`; + +const EVENT = { + CLICK: `click.${EVENT_NAMESPACE}`, + READYTOREMOVE: `readyToRemove.${EVENT_NAMESPACE}`, + READYTODESTROY: `readyToDestroy.${EVENT_NAMESPACE}` +}; + +export default class { + constructor(options) { + + this.options = options; + this.wrapper = options.wrapper; + this.overrideClass = options.overrideClass ? options.overrideClass : ''; + this.clickedLink = options.clickedLink; + + } + + launch() { + if(isDebug) { + console.log("---- Launch transition πŸ‘Š -----"); + } + + $html + .removeClass('dom-is-loaded dom-is-animated ') + .addClass(`dom-is-loading ${this.overrideClass}`); + + } + + hideView(oldView, newView) { + if(isDebug) { + console.log('----- ❌ [VIEW]:hide - ', oldView.getAttribute('data-template')); + } + + // launch it at the end (animations...) + $document.triggerHandler({ + type:EVENT.READYTOREMOVE, + oldView: oldView, + newView: newView + }); + + } + + + displayView(view) { + + if(isDebug) { + console.log('----- βœ… [VIEW]:display :', view.getAttribute('data-template')); + } + + $html.attr('data-template', view.getAttribute('data-template')); + + setTimeout(() => { + + $html + .addClass('dom-is-loaded') + .removeClass('dom-is-loading'); + + setTimeout(() => { + $html + .removeClass(this.overrideClass) + .addClass('dom-is-animated'); + }, 1000); + + // launch it at the end (animations...) + $document.triggerHandler({ + type:EVENT.READYTODESTROY + }); + + },1000); + } + + + destroy() { + if(isDebug) { + console.log("---- ❌ [transition]:destroy -----"); + } + } +} diff --git a/assets/scripts/transitions/CustomTransition.js b/assets/scripts/transitions/CustomTransition.js new file mode 100644 index 0000000..2fecbdb --- /dev/null +++ b/assets/scripts/transitions/CustomTransition.js @@ -0,0 +1,22 @@ +import { APP_NAME, $document, $html, isDebug, $pjaxWrapper } from '../utils/environment'; +import BaseTransition from './BaseTransition'; + +const MODULE_NAME = 'Transition'; +const EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`; + +const EVENT = { + CLICK: `click.${EVENT_NAMESPACE}`, + READYTOREMOVE: `readyToRemove.${EVENT_NAMESPACE}`, + READYTODISPLAY: `readyToDisplay.${EVENT_NAMESPACE}`, + READYTODESTROY: `readyToDestroy.${EVENT_NAMESPACE}` +}; + + +export default class extends BaseTransition{ + constructor(options) { + super(options); + + this.overrideClass = '-custom-transition'; + } + +} diff --git a/assets/scripts/transitions/DefaultTransition.js b/assets/scripts/transitions/DefaultTransition.js deleted file mode 100644 index baa10a7..0000000 --- a/assets/scripts/transitions/DefaultTransition.js +++ /dev/null @@ -1,57 +0,0 @@ -/* jshint esnext: true */ -import { APP_NAME, $document, $html, $barba } from '../utils/environment'; -import { EVENT as APP_EVENT } from '../App'; - -function DefaultTransition(options) { - options = options || {}; - const startCallback = (typeof options.startCallback === 'function') ? options.startCallback : function(){}; - const overrideClass = (typeof options.overrideClass === 'string') ? options.overrideClass : ''; - - return Barba.BaseTransition.extend({ - start: function() { - $html - .removeClass('dom-is-loaded dom-is-animated') - .addClass(`dom-is-loading ${overrideClass}`); - - startCallback(); - - /* Close any overlays */ - - setTimeout(() => { - Promise - .all([this.newContainerLoading]) - .then(this.finish.bind(this)); - }, 1000); - }, - finish: function() { - $document.triggerHandler({ - type: APP_EVENT.DELETE_SCOPED_MODULES, - $scope: $barba - }); - - this.done(); - - const $el = $(this.newContainer); - - // Get the template name of the new container and set it to the DOM - $html.attr('data-template', $el.data('template')); - - $document.triggerHandler({ - type: APP_EVENT.INIT_SCOPED_MODULES, - isBarba: true - }); - - $html - .addClass('dom-is-loaded') - .removeClass('dom-is-loading'); - - setTimeout(() => { - $html - .removeClass(overrideClass) - .addClass('dom-is-animated'); - }, 1000); - } - }); -} - -export default DefaultTransition; diff --git a/assets/scripts/transitions/TransitionManager.js b/assets/scripts/transitions/TransitionManager.js index 1fc77d9..4ac9eeb 100644 --- a/assets/scripts/transitions/TransitionManager.js +++ b/assets/scripts/transitions/TransitionManager.js @@ -1,81 +1,199 @@ /* jshint esnext: true */ -import { APP_NAME, $document, $html, isDebug } from '../utils/environment'; +import { APP_NAME, $document, $html, isDebug, $pjaxWrapper } from '../utils/environment'; +import { EVENT as APP_EVENT } from '../App'; -import DefaultTransition from './DefaultTransition'; +//List here all of your transitions +import * as transitions from './transitions'; -const MODULE_NAME = 'TransitionManager'; +const MODULE_NAME = 'Transition'; const EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`; const EVENT = { - GOTO: `goto.${EVENT_NAMESPACE}` + CLICK: `click.${EVENT_NAMESPACE}`, + READYTOREMOVE: `readyToRemove.${EVENT_NAMESPACE}`, + READYTODESTROY: `readyToDestroy.${EVENT_NAMESPACE}` }; +/* + +@todo : + +- βœ… get data-transition on clicked link -> launch() and add switch(){} +- ❌ add goto listener +- ❌ add newPageReady functon with google analytics send (maybe pjax do that?) +- βœ… add overrideClass system for all transitions +- βœ… add base class manager like old DefaultTransition (dom-is-loaded, dom-is-loading etc..) + + + +======= SCHEMA ======= + +[] : listener +* : trigger event + +[pjax:send] -> (transition) launch() + +[pjax:switch] (= new view is loaded) -> (transition) hideView()-> hide animations & *readyToRemove + +[readyToRemove] -> remove() -> delete modules + -> remove oldView from the DOM, and innerHTMl newView + -> display() + +display() -> (transition) displayView() -> display animations & *readyToRemove + -> init new modules + +[readyToRemove] -> reinit() + +*/ + export default class { constructor() { - let clickedLink = undefined; - let transition = ''; + // jQuery ondomready $(() => { - this.load() + this.load(); }); - $document.on(EVENT.GOTO, (event) => { - if (!window.history.pushState) { - window.location = event.options.location; - } else { - transition = event.options.transition; - Barba.Pjax.goTo(event.options.location); - } + this.transition = new transitions['BaseTransition']({ + wrapper: this.wrapper }); - // Define different page transitions - Barba.Pjax.getTransition = function() { - transition = (clickedLink instanceof Node) ? clickedLink.getAttribute('data-transition') : (typeof transition === 'string' ? transition : ''); + /* + ===== PJAX CONFIGURATION ===== + */ - let TransitionObject; + this.containerClass = '.js-pjax-container'; + this.wrapperId = 'js-pjax-wrapper'; + this.noPjaxRequestClass = 'no-transition'; + this.wrapper = document.getElementById(this.wrapperId); - switch (transition) { - default: - TransitionObject = DefaultTransition(); - } + this.options = { + debug: false, + cacheBust: false, + elements: [`a:not(.${this.noPjaxRequestClass})`,'form[action]'], + selectors: ['title',`${this.containerClass}`], + switches: {} + }; + this.options.switches[this.containerClass] = (oldEl, newEl, options) => this.switch(oldEl, newEl, options) + this.pjax = new Pjax(this.options); - clickedLink = undefined; - transition = ''; + /* + ===== LISTENERS ===== + */ - return TransitionObject; + document.addEventListener('pjax:send',(e) => this.send(e)); + + + $document.on(EVENT.READYTOREMOVE,(event) => { + this.remove(event.oldView, event.newView); + }); + $document.on(EVENT.READYTODESTROY,(event) => { + this.reinit(); + }); + } + + + /** + * (PJAX) Launch when pjax receive a request + * get & manage data-transition,init and launch it + * @param {event} + * @return void + */ + send(e) { + if(isDebug) { + console.log("---- Launch request πŸ™Œ -----"); } - Barba.Dispatcher.on('linkClicked', (HTMLElement, MouseEvent) => { - clickedLink = HTMLElement; + let el = e.triggerElement; + + let transition = el.getAttribute('data-transition') ? el.getAttribute('data-transition') : 'BaseTransition'; + $html.attr('data-transition',transition); + + // options available : wrapper, overrideClass + this.transition = new transitions[transition]({ + wrapper: this.wrapper, + clickedLink: el }); - Barba.Dispatcher.on('newPageReady', (currentStatus, prevStatus, container, currentHTML) => { - // Fetch any inline script elements. - const scripts = container.querySelectorAll('script.js-inline'); + this.transition.launch(); - if (scripts instanceof window.NodeList) { - let i = 0; - let len = scripts.length; - for (; i < len; i++) { - eval(scripts[i].innerHTML); - } - } + } - /** - * Execute any third party features. - */ + /** + * (PJAX) Launch when new page is loaded + * @param {js dom element}, + * @param {js dom element} + * @param {options : pjax options} + * @return void + */ + switch(oldView, newView, options) { + if(isDebug) { + console.log('---- Next view loaded πŸ‘Œ -----'); + } + this.transition.hideView(oldView, newView); - // Google Analytics - if (window.ga && !isDebug) { - ga('send', 'pageview'); - } + this.pjax.onSwitch(); + + } + + /** + * Launch when you trigger EVENT.READYTOREMOVE in your transition -> hideView(), at the end + * after oldView hidden, delete modules and launch this.display() + * @param {js dom element}, + * @param {js dom element} + * @return void + */ + remove(oldView, newView) { + + $document.triggerHandler({ + type: APP_EVENT.DELETE_SCOPED_MODULES, + $scope: $pjaxWrapper }); - Barba.Pjax.Dom.containerClass = 'js-barba-container'; - Barba.Pjax.Dom.wrapperId = 'js-barba-wrapper'; + oldView.remove(); - Barba.Pjax.start(); + this.display(newView); + } + + /** + * launch after this.remove() + * @param {js dom element}, + * @return void + */ + display(view) { + this.wrapper.innerHTML = view.outerHTML; + + // Fetch any inline script elements. + const scripts = view.querySelectorAll('script.js-inline'); + + if (scripts instanceof window.NodeList) { + let i = 0; + let len = scripts.length; + for (; i < len; i++) { + eval(scripts[i].innerHTML); + } + } + + $document.triggerHandler({ + type: APP_EVENT.INIT_SCOPED_MODULES, + isPjax: true + }); + + this.transition.displayView(view); + + } + + /** + * Launch when you trigger EVENT.READYTODESTROY in your transition -> displayView(), at the end + * @return void + */ + reinit() { + this.transition.destroy(); + $html.attr('data-transition',''); + this.transition = new transitions['BaseTransition']({ + wrapper: this.wrapper + }); } /** diff --git a/assets/scripts/transitions/transitions.js b/assets/scripts/transitions/transitions.js new file mode 100644 index 0000000..fd440be --- /dev/null +++ b/assets/scripts/transitions/transitions.js @@ -0,0 +1,2 @@ +export {default as BaseTransition} from './BaseTransition'; +export {default as CustomTransition} from './CustomTransition'; diff --git a/assets/scripts/utils/environment.js b/assets/scripts/utils/environment.js index 610b668..b809e10 100644 --- a/assets/scripts/utils/environment.js +++ b/assets/scripts/utils/environment.js @@ -5,8 +5,8 @@ const $document = $(document); const $window = $(window); const $html = $(document.documentElement).removeClass('has-no-js').addClass('has-js'); const $body = $(document.body); -const $barba = $('#js-barba-wrapper'); +const $pjaxWrapper = $('#js-pjax-wrapper'); const isDebug = !!$html.data('debug'); -export { APP_NAME, DATA_API_KEY, $document, $window, $html, $body, isDebug, $barba }; +export { APP_NAME, DATA_API_KEY, $document, $window, $html, $body, isDebug, $pjaxWrapper }; diff --git a/build/grunt/config/browserSync.js b/build/grunt/config/browserSync.js index f0fba7e..8f45b30 100644 --- a/build/grunt/config/browserSync.js +++ b/build/grunt/config/browserSync.js @@ -1,7 +1,7 @@ module.exports = { options: { open : false, - proxy : 'localhost', + proxy : 'locomotive-boilerplate.test', port : 3000, watchTask : true, notify : false @@ -12,7 +12,8 @@ module.exports = { '<%= paths.css.dist %>/**/*.css', '<%= paths.js.dist %>/**/*.js', '<%= paths.img.dist %>/**/*.svg', - '**/*.php' + '**/*.php', + '**/*.html', ] } } diff --git a/build/grunt/config/concat.js b/build/grunt/config/concat.js index cde1e6e..9c507ce 100644 --- a/build/grunt/config/concat.js +++ b/build/grunt/config/concat.js @@ -5,7 +5,7 @@ module.exports = { }, src : [ '<%= paths.js.src %>/vendors/**/*.js', - '<%= paths.npm %>/barba.js/dist/barba.js', + '<%= paths.npm %>/pjax/pjax.js', '<%= paths.npm %>/svg4everybody/dist/svg4everybody.js' ], dest : '<%= paths.js.dist %>/vendors.js' diff --git a/package.json b/package.json index f3efa69..80c062a 100644 --- a/package.json +++ b/package.json @@ -6,7 +6,7 @@ "version": "1.0.0", "author": "Locomotive ", "dependencies": { - "barba.js": "0.0.0", + "pjax": "0.0.0", "svg4everybody": "0.0.0" }, "devDependencies": { diff --git a/www/assets/scripts/app.js b/www/assets/scripts/app.js index 54721a1..5ef86ac 100644 --- a/www/assets/scripts/app.js +++ b/www/assets/scripts/app.js @@ -6,6 +6,12 @@ Object.defineProperty(exports, "__esModule", { }); exports.EVENT = undefined; +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /* jshint esnext: true */ + + +// Basic modules + + var _environment = require('./utils/environment'); var _globals = require('./globals'); @@ -26,11 +32,7 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* jshint esnext: true */ - - -// Basic modules - +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } var MODULE_NAME = 'App'; var EVENT_NAMESPACE = _environment.APP_NAME + '.' + MODULE_NAME; @@ -70,115 +72,120 @@ var App = function () { */ - App.prototype.deleteModules = function deleteModules(event) { - var destroyAll = true; - var moduleIds = []; + _createClass(App, [{ + key: 'deleteModules', + value: function deleteModules(event) { + var destroyAll = true; + var moduleIds = []; - // Check for scope first - if (event.$scope instanceof jQuery && event.$scope.length > 0) { - // Modules within scope - var $modules = event.$scope.find('[data-module]'); + // Check for scope first + if (event.$scope instanceof jQuery && event.$scope.length > 0) { + // Modules within scope + var $modules = event.$scope.find('[data-module]'); - // Determine their uids - moduleIds = $.makeArray($modules.map(function (index) { - return $modules.eq(index).data('uid'); - })); + // Determine their uids + moduleIds = $.makeArray($modules.map(function (index) { + return $modules.eq(index).data('uid'); + })); - if (moduleIds.length > 0) { - destroyAll = false; - } else { - return this; - } - } - - // Loop modules and destroying all of them, or specific ones - var i = this.currentModules.length; - - while (i--) { - if (destroyAll || (0, _array.arrayContains)(moduleIds, this.currentModules[i].uid)) { - (0, _array.removeFromArray)(moduleIds, this.currentModules[i].uid); - this.currentModules[i].destroy(); - this.currentModules.splice(i); - } - } - - return this; - }; - - /** - * Execute global functions and settings - * Allows you to initialize global modules only once if you need - * (ex.: when using Barba.js or SmoothState.js) - * @return {Object} Self (allows chaining) - */ - - - App.prototype.initGlobals = function initGlobals(firstBlood) { - (0, _globals2.default)(firstBlood); - return this; - }; - - /** - * Find modules and initialize them - * @param {Object} event The event being triggered. - * @return {Object} Self (allows chaining) - */ - - - App.prototype.initModules = function initModules(event) { - // Elements with module - var $moduleEls = []; - - // If first blood, load all modules in the DOM - // If scoped, render elements with modules - // If Barba, load modules contained in Barba container - if (event.firstBlood) { - $moduleEls = _environment.$document.find('[data-module]'); - } else if (event.$scope instanceof jQuery && event.$scope.length > 0) { - $moduleEls = event.$scope.find('[data-module]'); - } else if (event.isBarba) { - $moduleEls = _environment.$barba.find('[data-module]'); - } - - // Loop through elements - var i = 0; - var elsLen = $moduleEls.length; - - for (; i < elsLen; i++) { - - // Current element - var el = $moduleEls[i]; - - // All data- attributes considered as options - var options = (0, _html.getNodeData)(el); - - // Add current DOM element and jQuery element - options.el = el; - options.$el = $moduleEls.eq(i); - - // Module does exist at this point - var attr = options.module; - - // Splitting modules found in the data-attribute - var moduleIdents = attr.split(/[,\s]+/g); - - // Loop modules - var j = 0; - var modulesLen = moduleIdents.length; - - for (; j < modulesLen; j++) { - var moduleAttr = moduleIdents[j]; - - if (typeof this.modules[moduleAttr] === 'function') { - var module = new this.modules[moduleAttr](options); - this.currentModules.push(module); - module.init(); + if (moduleIds.length > 0) { + destroyAll = false; + } else { + return this; } } + + // Loop modules and destroying all of them, or specific ones + var i = this.currentModules.length; + + while (i--) { + if (destroyAll || (0, _array.arrayContains)(moduleIds, this.currentModules[i].uid)) { + (0, _array.removeFromArray)(moduleIds, this.currentModules[i].uid); + this.currentModules[i].destroy(); + this.currentModules.splice(i); + } + } + + return this; } - return this; - }; + /** + * Execute global functions and settings + * Allows you to initialize global modules only once if you need + * (ex.: when using Barba.js or SmoothState.js) + * @return {Object} Self (allows chaining) + */ + + }, { + key: 'initGlobals', + value: function initGlobals(firstBlood) { + (0, _globals2.default)(firstBlood); + return this; + } + + /** + * Find modules and initialize them + * @param {Object} event The event being triggered. + * @return {Object} Self (allows chaining) + */ + + }, { + key: 'initModules', + value: function initModules(event) { + // Elements with module + var $moduleEls = []; + + // If first blood, load all modules in the DOM + // If scoped, render elements with modules + // If Barba, load modules contained in Barba container + if (event.firstBlood) { + $moduleEls = _environment.$document.find('[data-module]'); + } else if (event.$scope instanceof jQuery && event.$scope.length > 0) { + $moduleEls = event.$scope.find('[data-module]'); + } else if (event.isPjax) { + $moduleEls = _environment.$pjaxWrapper.find('[data-module]'); + } + + // Loop through elements + var i = 0; + var elsLen = $moduleEls.length; + + for (; i < elsLen; i++) { + + // Current element + var el = $moduleEls[i]; + + // All data- attributes considered as options + var options = (0, _html.getNodeData)(el); + + // Add current DOM element and jQuery element + options.el = el; + options.$el = $moduleEls.eq(i); + + // Module does exist at this point + var attr = options.module; + + // Splitting modules found in the data-attribute + var moduleIdents = attr.split(/[,\s]+/g); + + // Loop modules + var j = 0; + var modulesLen = moduleIdents.length; + + for (; j < modulesLen; j++) { + var moduleAttr = moduleIdents[j]; + + if (typeof this.modules[moduleAttr] === 'function') { + var module = new this.modules[moduleAttr](options); + this.currentModules.push(module); + module.init(); + } + } + } + + return this; + } + }]); return App; }(); @@ -195,7 +202,7 @@ var App = function () { }); })(); -},{"./globals":2,"./modules":3,"./utils/array":8,"./utils/environment":10,"./utils/html":11,"./utils/is":12}],2:[function(require,module,exports){ +},{"./globals":2,"./modules":3,"./utils/array":10,"./utils/environment":12,"./utils/html":13,"./utils/is":14}],2:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -216,7 +223,7 @@ var _TransitionManager2 = _interopRequireDefault(_TransitionManager); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -},{"./transitions/TransitionManager":7}],3:[function(require,module,exports){ +},{"./transitions/TransitionManager":8}],3:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -241,6 +248,8 @@ Object.defineProperty(exports, "__esModule", { value: true }); +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* jshint esnext: true */ @@ -263,13 +272,17 @@ var _class = function () { this.$el.data('uid', this.uid); } - _class.prototype.init = function init() {}; - - _class.prototype.destroy = function destroy() { - if (this.$el) { - this.$el.removeData('uid'); + _createClass(_class, [{ + key: 'init', + value: function init() {} + }, { + key: 'destroy', + value: function destroy() { + if (this.$el) { + this.$el.removeData('uid'); + } } - }; + }]); return _class; }(); @@ -283,6 +296,10 @@ Object.defineProperty(exports, "__esModule", { value: true }); +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }; + var _environment = require('../utils/environment'); var _AbstractModule2 = require('./AbstractModule'); @@ -311,157 +328,377 @@ var _class = function (_AbstractModule) { function _class(options) { _classCallCheck(this, _class); - return _possibleConstructorReturn(this, _AbstractModule.call(this, options)); - // Declaration of properties + var _this = _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).call(this, options)); + + console.log('πŸ”¨ [module]:constructor - Example'); + + return _this; } - _class.prototype.init = function init() { - // Set events and such - }; + _createClass(_class, [{ + key: 'init', + value: function init() { + // Set events and such - _class.prototype.destroy = function destroy() { - _AbstractModule.prototype.destroy.call(this); - this.$el.off('.' + EVENT_NAMESPACE); - }; + } + }, { + key: 'destroy', + value: function destroy() { + console.log('❌ [module]:destroy - Example'); + _get(_class.prototype.__proto__ || Object.getPrototypeOf(_class.prototype), 'destroy', this).call(this); + this.$el.off('.' + EVENT_NAMESPACE); + } + }]); return _class; }(_AbstractModule3.default); exports.default = _class; -},{"../utils/environment":10,"./AbstractModule":4}],6:[function(require,module,exports){ +},{"../utils/environment":12,"./AbstractModule":4}],6:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _environment = require('../utils/environment'); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var MODULE_NAME = 'Transition'; +var EVENT_NAMESPACE = _environment.APP_NAME + '.' + MODULE_NAME; + +var EVENT = { + CLICK: 'click.' + EVENT_NAMESPACE, + READYTOREMOVE: 'readyToRemove.' + EVENT_NAMESPACE, + READYTODESTROY: 'readyToDestroy.' + EVENT_NAMESPACE +}; + +var _class = function () { + function _class(options) { + _classCallCheck(this, _class); + + this.options = options; + this.wrapper = options.wrapper; + this.overrideClass = options.overrideClass ? options.overrideClass : ''; + this.clickedLink = options.clickedLink; + } + + _createClass(_class, [{ + key: 'launch', + value: function launch() { + if (_environment.isDebug) { + console.log("---- Launch transition πŸ‘Š -----"); + } + + _environment.$html.removeClass('dom-is-loaded dom-is-animated ').addClass('dom-is-loading ' + this.overrideClass); + } + }, { + key: 'hideView', + value: function hideView(oldView, newView) { + if (_environment.isDebug) { + console.log('----- ❌ [VIEW]:hide - ', oldView.getAttribute('data-template')); + } + + // launch it at the end (animations...) + _environment.$document.triggerHandler({ + type: EVENT.READYTOREMOVE, + oldView: oldView, + newView: newView + }); + } + }, { + key: 'displayView', + value: function displayView(view) { + var _this = this; + + if (_environment.isDebug) { + console.log('----- βœ… [VIEW]:display :', view.getAttribute('data-template')); + } + + _environment.$html.attr('data-template', view.getAttribute('data-template')); + + setTimeout(function () { + + _environment.$html.addClass('dom-is-loaded').removeClass('dom-is-loading'); + + setTimeout(function () { + _environment.$html.removeClass(_this.overrideClass).addClass('dom-is-animated'); + }, 1000); + + // launch it at the end (animations...) + _environment.$document.triggerHandler({ + type: EVENT.READYTODESTROY + }); + }, 1000); + } + }, { + key: 'destroy', + value: function destroy() { + if (_environment.isDebug) { + console.log("---- ❌ [transition]:destroy -----"); + } + } + }]); + + return _class; +}(); + +exports.default = _class; + +},{"../utils/environment":12}],7:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _environment = require('../utils/environment'); + +var _BaseTransition2 = require('./BaseTransition'); + +var _BaseTransition3 = _interopRequireDefault(_BaseTransition2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var MODULE_NAME = 'Transition'; +var EVENT_NAMESPACE = _environment.APP_NAME + '.' + MODULE_NAME; + +var EVENT = { + CLICK: 'click.' + EVENT_NAMESPACE, + READYTOREMOVE: 'readyToRemove.' + EVENT_NAMESPACE, + READYTODISPLAY: 'readyToDisplay.' + EVENT_NAMESPACE, + READYTODESTROY: 'readyToDestroy.' + EVENT_NAMESPACE +}; + +var _class = function (_BaseTransition) { + _inherits(_class, _BaseTransition); + + function _class(options) { + _classCallCheck(this, _class); + + var _this = _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).call(this, options)); + + _this.overrideClass = '-custom-transition'; + return _this; + } + + return _class; +}(_BaseTransition3.default); + +exports.default = _class; + +},{"../utils/environment":12,"./BaseTransition":6}],8:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /* jshint esnext: true */ + + +//List here all of your transitions + + var _environment = require('../utils/environment'); var _App = require('../App'); -/* jshint esnext: true */ -function DefaultTransition(options) { - options = options || {}; - var startCallback = typeof options.startCallback === 'function' ? options.startCallback : function () {}; - var overrideClass = typeof options.overrideClass === 'string' ? options.overrideClass : ''; +var _transitions = require('./transitions'); - return Barba.BaseTransition.extend({ - start: function start() { - var _this = this; +var transitions = _interopRequireWildcard(_transitions); - _environment.$html.removeClass('dom-is-loaded dom-is-animated').addClass('dom-is-loading ' + overrideClass); +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } - startCallback(); +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - /* Close any overlays */ - - setTimeout(function () { - Promise.all([_this.newContainerLoading]).then(_this.finish.bind(_this)); - }, 1000); - }, - finish: function finish() { - _environment.$document.triggerHandler({ - type: _App.EVENT.DELETE_SCOPED_MODULES, - $scope: _environment.$barba - }); - - this.done(); - - var $el = $(this.newContainer); - - // Get the template name of the new container and set it to the DOM - _environment.$html.attr('data-template', $el.data('template')); - - _environment.$document.triggerHandler({ - type: _App.EVENT.INIT_SCOPED_MODULES, - isBarba: true - }); - - _environment.$html.addClass('dom-is-loaded').removeClass('dom-is-loading'); - - setTimeout(function () { - _environment.$html.removeClass(overrideClass).addClass('dom-is-animated'); - }, 1000); - } - }); -} - -exports.default = DefaultTransition; - -},{"../App":1,"../utils/environment":10}],7:[function(require,module,exports){ -'use strict'; - -Object.defineProperty(exports, "__esModule", { - value: true -}); - -var _environment = require('../utils/environment'); - -var _DefaultTransition = require('./DefaultTransition'); - -var _DefaultTransition2 = _interopRequireDefault(_DefaultTransition); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /* jshint esnext: true */ - - -var MODULE_NAME = 'TransitionManager'; +var MODULE_NAME = 'Transition'; var EVENT_NAMESPACE = _environment.APP_NAME + '.' + MODULE_NAME; var EVENT = { - GOTO: 'goto.' + EVENT_NAMESPACE + CLICK: 'click.' + EVENT_NAMESPACE, + READYTOREMOVE: 'readyToRemove.' + EVENT_NAMESPACE, + READYTODESTROY: 'readyToDestroy.' + EVENT_NAMESPACE }; +/* + +@todo : + +- βœ… get data-transition on clicked link -> launch() and add switch(){} +- ❌ add goto listener +- ❌ add newPageReady functon with google analytics send (maybe pjax do that?) +- βœ… add overrideClass system for all transitions +- βœ… add base class manager like old DefaultTransition (dom-is-loaded, dom-is-loading etc..) + + + +======= SCHEMA ======= + +[] : listener +* : trigger event + +[pjax:send] -> (transition) launch() + +[pjax:switch] (= new view is loaded) -> (transition) hideView()-> hide animations & *readyToRemove + +[readyToRemove] -> remove() -> delete modules + -> remove oldView from the DOM, and innerHTMl newView + -> display() + +display() -> (transition) displayView() -> display animations & *readyToRemove + -> init new modules + +[readyToRemove] -> reinit() + +*/ + var _class = function () { function _class() { var _this = this; _classCallCheck(this, _class); - var clickedLink = undefined; - var transition = ''; - // jQuery ondomready $(function () { _this.load(); }); - _environment.$document.on(EVENT.GOTO, function (event) { - if (!window.history.pushState) { - window.location = event.options.location; - } else { - transition = event.options.transition; - Barba.Pjax.goTo(event.options.location); - } + this.transition = new transitions['BaseTransition']({ + wrapper: this.wrapper }); - // Define different page transitions - Barba.Pjax.getTransition = function () { - transition = clickedLink instanceof Node ? clickedLink.getAttribute('data-transition') : typeof transition === 'string' ? transition : ''; + /* + ===== PJAX CONFIGURATION ===== + */ - var TransitionObject = void 0; + this.containerClass = '.js-pjax-container'; + this.wrapperId = 'js-pjax-wrapper'; + this.noPjaxRequestClass = 'no-transition'; + this.wrapper = document.getElementById(this.wrapperId); - switch (transition) { - default: - TransitionObject = (0, _DefaultTransition2.default)(); - } - - clickedLink = undefined; - transition = ''; - - return TransitionObject; + this.options = { + debug: false, + cacheBust: false, + elements: ['a:not(.' + this.noPjaxRequestClass + ')', 'form[action]'], + selectors: ['title', '' + this.containerClass], + switches: {} }; + this.options.switches[this.containerClass] = function (oldEl, newEl, options) { + return _this.switch(oldEl, newEl, options); + }; + this.pjax = new Pjax(this.options); - Barba.Dispatcher.on('linkClicked', function (HTMLElement, MouseEvent) { - clickedLink = HTMLElement; + /* + ===== LISTENERS ===== + */ + + document.addEventListener('pjax:send', function (e) { + return _this.send(e); }); - Barba.Dispatcher.on('newPageReady', function (currentStatus, prevStatus, container, currentHTML) { + _environment.$document.on(EVENT.READYTOREMOVE, function (event) { + _this.remove(event.oldView, event.newView); + }); + _environment.$document.on(EVENT.READYTODESTROY, function (event) { + _this.reinit(); + }); + } + + /** + * (PJAX) Launch when pjax receive a request + * get & manage data-transition,init and launch it + * @param {event} + * @return void + */ + + + _createClass(_class, [{ + key: 'send', + value: function send(e) { + if (_environment.isDebug) { + console.log("---- Launch request πŸ™Œ -----"); + } + + var el = e.triggerElement; + + var transition = el.getAttribute('data-transition') ? el.getAttribute('data-transition') : 'BaseTransition'; + _environment.$html.attr('data-transition', transition); + + // options available : wrapper, overrideClass + this.transition = new transitions[transition]({ + wrapper: this.wrapper, + clickedLink: el + }); + + this.transition.launch(); + } + + /** + * (PJAX) Launch when new page is loaded + * @param {js dom element}, + * @param {js dom element} + * @param {options : pjax options} + * @return void + */ + + }, { + key: 'switch', + value: function _switch(oldView, newView, options) { + if (_environment.isDebug) { + console.log('---- Next view loaded πŸ‘Œ -----'); + } + this.transition.hideView(oldView, newView); + + this.pjax.onSwitch(); + } + + /** + * Launch when you trigger EVENT.READYTOREMOVE in your transition -> hideView(), at the end + * after oldView hidden, delete modules and launch this.display() + * @param {js dom element}, + * @param {js dom element} + * @return void + */ + + }, { + key: 'remove', + value: function remove(oldView, newView) { + + _environment.$document.triggerHandler({ + type: _App.EVENT.DELETE_SCOPED_MODULES, + $scope: _environment.$pjaxWrapper + }); + + oldView.remove(); + + this.display(newView); + } + + /** + * launch after this.remove() + * @param {js dom element}, + * @return void + */ + + }, { + key: 'display', + value: function display(view) { + this.wrapper.innerHTML = view.outerHTML; + // Fetch any inline script elements. - var scripts = container.querySelectorAll('script.js-inline'); + var scripts = view.querySelectorAll('script.js-inline'); if (scripts instanceof window.NodeList) { var i = 0; @@ -471,43 +708,79 @@ var _class = function () { } } - /** - * Execute any third party features. - */ + _environment.$document.triggerHandler({ + type: _App.EVENT.INIT_SCOPED_MODULES, + isPjax: true + }); - // Google Analytics - if (window.ga && !_environment.isDebug) { - ga('send', 'pageview'); - } - }); + this.transition.displayView(view); + } - Barba.Pjax.Dom.containerClass = 'js-barba-container'; - Barba.Pjax.Dom.wrapperId = 'js-barba-wrapper'; + /** + * Launch when you trigger EVENT.READYTODESTROY in your transition -> displayView(), at the end + * @return void + */ - Barba.Pjax.start(); - } + }, { + key: 'reinit', + value: function reinit() { + this.transition.destroy(); + _environment.$html.attr('data-transition', ''); + this.transition = new transitions['BaseTransition']({ + wrapper: this.wrapper + }); + } - /** - * DOM is loaded - * - * @return {void} - */ + /** + * DOM is loaded + * + * @return {void} + */ - - _class.prototype.load = function load() { - _environment.$html.addClass('dom-is-loaded'); - _environment.$html.removeClass('dom-is-loading'); - setTimeout(function () { - _environment.$html.addClass('dom-is-animated'); - }, 1000); - }; + }, { + key: 'load', + value: function load() { + _environment.$html.addClass('dom-is-loaded'); + _environment.$html.removeClass('dom-is-loading'); + setTimeout(function () { + _environment.$html.addClass('dom-is-animated'); + }, 1000); + } + }]); return _class; }(); exports.default = _class; -},{"../utils/environment":10,"./DefaultTransition":6}],8:[function(require,module,exports){ +},{"../App":1,"../utils/environment":12,"./transitions":9}],9:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _BaseTransition = require('./BaseTransition'); + +Object.defineProperty(exports, 'BaseTransition', { + enumerable: true, + get: function get() { + return _interopRequireDefault(_BaseTransition).default; + } +}); + +var _CustomTransition = require('./CustomTransition'); + +Object.defineProperty(exports, 'CustomTransition', { + enumerable: true, + get: function get() { + return _interopRequireDefault(_CustomTransition).default; + } +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +},{"./BaseTransition":6,"./CustomTransition":7}],10:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -521,6 +794,7 @@ exports.lastItem = lastItem; exports.removeFromArray = removeFromArray; exports.toArray = toArray; exports.findByKeyValue = findByKeyValue; +exports.cloneArray = cloneArray; var _is = require('./is'); @@ -607,7 +881,11 @@ function findByKeyValue(array, key, value) { }); } -},{"./is":12}],9:[function(require,module,exports){ +function cloneArray(array) { + return JSON.parse(JSON.stringify(array)); +} + +},{"./is":14}],11:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { @@ -630,7 +908,7 @@ exports.default = function (func, wait, immediate) { }; }; -},{}],10:[function(require,module,exports){ +},{}],12:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -643,7 +921,7 @@ var $document = $(document); var $window = $(window); var $html = $(document.documentElement).removeClass('has-no-js').addClass('has-js'); var $body = $(document.body); -var $barba = $('#js-barba-wrapper'); +var $pjaxWrapper = $('#js-pjax-wrapper'); var isDebug = !!$html.data('debug'); @@ -654,9 +932,9 @@ exports.$window = $window; exports.$html = $html; exports.$body = $body; exports.isDebug = isDebug; -exports.$barba = $barba; +exports.$pjaxWrapper = $pjaxWrapper; -},{}],11:[function(require,module,exports){ +},{}],13:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -757,7 +1035,7 @@ function getData(data) { return data; } -},{}],12:[function(require,module,exports){ +},{}],14:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -810,7 +1088,7 @@ function isFunction(thing) { return thing && getType.toString.call(thing) === '[object Function]'; } -},{}],13:[function(require,module,exports){ +},{}],15:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -883,7 +1161,7 @@ function scrollTo($element, options) { return deferred.promise(); } -},{"./is":12}],14:[function(require,module,exports){ +},{"./is":14}],16:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { @@ -1018,5 +1296,5 @@ function visibilityApi(options) { exports.visibilityApi = visibilityApi; -},{"./array":8,"./environment":10,"./is":12}]},{},[1,2,3,4,5,6,7,8,9,10,11,12,13,14]) -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","assets/scripts/App.js","assets/scripts/globals.js","assets/scripts/modules.js","assets/scripts/modules/AbstractModule.js","assets/scripts/modules/Example.js","assets/scripts/transitions/DefaultTransition.js","assets/scripts/transitions/TransitionManager.js","assets/scripts/utils/array.js","assets/scripts/utils/debounce.js","assets/scripts/utils/environment.js","assets/scripts/utils/html.js","assets/scripts/utils/is.js","assets/scripts/utils/scrollTo.js","assets/scripts/utils/visibility.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* jshint esnext: true */\nimport { APP_NAME, $document, $barba } from './utils/environment';\n\nimport globals from './globals';\n\nimport { arrayContains, removeFromArray } from './utils/array';\nimport { getNodeData } from './utils/html';\nimport { isFunction } from './utils/is';\n\n// Basic modules\nimport * as modules from './modules';\n\nconst MODULE_NAME = 'App';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nexport const EVENT = {\n    INIT_MODULES: `initModules.${EVENT_NAMESPACE}`,\n    INIT_SCOPED_MODULES: `initScopedModules.${EVENT_NAMESPACE}`,\n    DELETE_SCOPED_MODULES: `deleteScopedModules.${EVENT_NAMESPACE}`\n};\n\nclass App {\n    constructor() {\n        this.modules = modules;\n        this.currentModules = [];\n\n        $document.on(EVENT.INIT_MODULES, (event) => {\n            this.initGlobals(event.firstBlood)\n                .deleteModules(event)\n                .initModules(event);\n        });\n\n        $document.on(EVENT.INIT_SCOPED_MODULES, (event) => {\n            this.initModules(event);\n        });\n\n        $document.on(EVENT.DELETE_SCOPED_MODULES, (event) => {\n            this.deleteModules(event);\n        });\n    }\n\n    /**\n     * Destroy all existing modules or a specific scope of modules\n     * @param  {Object} event The event being triggered.\n     * @return {Object}       Self (allows chaining)\n     */\n    deleteModules(event) {\n        let destroyAll = true;\n        let moduleIds = [];\n\n        // Check for scope first\n        if (event.$scope instanceof jQuery && event.$scope.length > 0) {\n            // Modules within scope\n            const $modules = event.$scope.find('[data-module]');\n\n            // Determine their uids\n            moduleIds = $.makeArray($modules.map(function(index) {\n                return $modules.eq(index).data('uid');\n            }));\n\n            if (moduleIds.length > 0) {\n                destroyAll = false;\n            } else {\n                return this;\n            }\n        }\n\n        // Loop modules and destroying all of them, or specific ones\n        let i = this.currentModules.length;\n\n        while (i--) {\n            if (destroyAll || arrayContains(moduleIds, this.currentModules[i].uid)) {\n                removeFromArray(moduleIds, this.currentModules[i].uid);\n                this.currentModules[i].destroy();\n                this.currentModules.splice(i);\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Execute global functions and settings\n     * Allows you to initialize global modules only once if you need\n     * (ex.: when using Barba.js or SmoothState.js)\n     * @return {Object} Self (allows chaining)\n     */\n    initGlobals(firstBlood) {\n        globals(firstBlood);\n        return this;\n    }\n\n    /**\n     * Find modules and initialize them\n     * @param  {Object} event The event being triggered.\n     * @return {Object}       Self (allows chaining)\n     */\n    initModules(event) {\n        // Elements with module\n        let $moduleEls = [];\n\n        // If first blood, load all modules in the DOM\n        // If scoped, render elements with modules\n        // If Barba, load modules contained in Barba container\n        if (event.firstBlood) {\n            $moduleEls = $document.find('[data-module]');\n        } else if (event.$scope instanceof jQuery && event.$scope.length > 0) {\n            $moduleEls = event.$scope.find('[data-module]');\n        } else if (event.isBarba) {\n            $moduleEls = $barba.find('[data-module]');\n        }\n\n        // Loop through elements\n        let i = 0;\n        const elsLen = $moduleEls.length;\n\n        for (; i < elsLen; i++) {\n\n            // Current element\n            let el = $moduleEls[i];\n\n            // All data- attributes considered as options\n            let options = getNodeData(el);\n\n            // Add current DOM element and jQuery element\n            options.el = el;\n            options.$el = $moduleEls.eq(i);\n\n            // Module does exist at this point\n            let attr = options.module;\n\n            // Splitting modules found in the data-attribute\n            let moduleIdents = attr.split(/[,\\s]+/g);\n\n            // Loop modules\n            let j = 0;\n            let modulesLen = moduleIdents.length;\n\n            for (; j < modulesLen; j++) {\n                let moduleAttr = moduleIdents[j];\n\n                if (typeof this.modules[moduleAttr] === 'function') {\n                    let module = new this.modules[moduleAttr](options);\n                    this.currentModules.push(module);\n                    module.init();\n                }\n            }\n        }\n\n        return this;\n    }\n}\n\n// IIFE for loading the application\n// ==========================================================================\n(function() {\n    new App();\n    $document.triggerHandler({\n        type: EVENT.INIT_MODULES,\n        firstBlood: true\n    });\n})();\n","/* jshint esnext: true */\nimport TransitionManager from './transitions/TransitionManager';\n\nexport default function(firstBlood) {\n    svg4everybody();\n\n    if (firstBlood) {\n        const transitionManager = new TransitionManager();\n    }\n}\n","/* jshint esnext: true */\nexport {default as Example} from './modules/Example';\n","/* jshint esnext: true */\nlet uid = 0;\n\n/**\n * Abstract Module\n */\nexport default class {\n    constructor(options) {\n        this.$el = options.$el || null;\n        this.el  = options.el  || null;\n\n        // Generate a unique module identifier\n        this.uid = 'm-' + uid++;\n        // Use jQuery's data API to \"store it in the DOM\"\n        this.$el.data('uid', this.uid);\n    }\n\n    init() {}\n\n    destroy() {\n        if (this.$el) {\n            this.$el.removeData('uid')\n        }\n    }\n}\n","/* jshint esnext: true */\nimport { APP_NAME } from '../utils/environment';\nimport AbstractModule from './AbstractModule';\n\nconst MODULE_NAME = 'Example';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nconst EVENT = {\n    CLICK: `click.${EVENT_NAMESPACE}`\n};\n\nexport default class extends AbstractModule {\n    constructor(options) {\n        super(options);\n\n        // Declaration of properties\n    }\n\n    init() {\n        // Set events and such\n    }\n\n    destroy() {\n        super.destroy();\n        this.$el.off(`.${EVENT_NAMESPACE}`);\n    }\n}\n","/* jshint esnext: true */\nimport { APP_NAME, $document, $html, $barba } from '../utils/environment';\nimport { EVENT as APP_EVENT } from '../App';\n\nfunction DefaultTransition(options) {\n    options = options || {};\n    const startCallback = (typeof options.startCallback === 'function') ? options.startCallback : function(){};\n    const overrideClass = (typeof options.overrideClass === 'string') ? options.overrideClass : '';\n\n    return Barba.BaseTransition.extend({\n        start: function() {\n            $html\n                .removeClass('dom-is-loaded dom-is-animated')\n                .addClass(`dom-is-loading ${overrideClass}`);\n\n            startCallback();\n\n            /* Close any overlays */\n\n            setTimeout(() => {\n                Promise\n                  .all([this.newContainerLoading])\n                  .then(this.finish.bind(this));\n            }, 1000);\n        },\n        finish: function() {\n            $document.triggerHandler({\n                type:   APP_EVENT.DELETE_SCOPED_MODULES,\n                $scope: $barba\n            });\n\n            this.done();\n\n            const $el = $(this.newContainer);\n\n            // Get the template name of the new container and set it to the DOM\n            $html.attr('data-template', $el.data('template'));\n\n            $document.triggerHandler({\n                type: APP_EVENT.INIT_SCOPED_MODULES,\n                isBarba: true\n            });\n\n            $html\n                .addClass('dom-is-loaded')\n                .removeClass('dom-is-loading');\n\n            setTimeout(() => {\n                $html\n                    .removeClass(overrideClass)\n                    .addClass('dom-is-animated');\n            }, 1000);\n        }\n    });\n}\n\nexport default DefaultTransition;\n","/* jshint esnext: true */\nimport { APP_NAME, $document, $html, isDebug } from '../utils/environment';\n\nimport DefaultTransition from './DefaultTransition';\n\nconst MODULE_NAME = 'TransitionManager';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nconst EVENT = {\n    GOTO: `goto.${EVENT_NAMESPACE}`\n};\n\nexport default class {\n    constructor() {\n        let clickedLink = undefined;\n        let transition = '';\n\n        // jQuery ondomready\n        $(() => {\n            this.load()\n        });\n\n        $document.on(EVENT.GOTO, (event) => {\n            if (!window.history.pushState) {\n                window.location = event.options.location;\n            } else {\n                transition = event.options.transition;\n                Barba.Pjax.goTo(event.options.location);\n            }\n        });\n\n        // Define different page transitions\n        Barba.Pjax.getTransition = function() {\n            transition = (clickedLink instanceof Node) ? clickedLink.getAttribute('data-transition') : (typeof transition === 'string' ? transition : '');\n\n            let TransitionObject;\n\n            switch (transition) {\n                default:\n                    TransitionObject = DefaultTransition();\n            }\n\n            clickedLink = undefined;\n            transition = '';\n\n            return TransitionObject;\n        }\n\n        Barba.Dispatcher.on('linkClicked', (HTMLElement, MouseEvent) => {\n            clickedLink = HTMLElement;\n        });\n\n        Barba.Dispatcher.on('newPageReady', (currentStatus, prevStatus, container, currentHTML) => {\n            // Fetch any inline script elements.\n            const scripts = container.querySelectorAll('script.js-inline');\n\n            if (scripts instanceof window.NodeList) {\n                let i = 0;\n                let len = scripts.length;\n                for (; i < len; i++) {\n                    eval(scripts[i].innerHTML);\n                }\n            }\n\n            /**\n             * Execute any third party features.\n             */\n\n            // Google Analytics\n            if (window.ga && !isDebug) {\n                ga('send', 'pageview');\n            }\n        });\n\n        Barba.Pjax.Dom.containerClass = 'js-barba-container';\n        Barba.Pjax.Dom.wrapperId = 'js-barba-wrapper';\n\n        Barba.Pjax.start();\n    }\n\n    /**\n     * DOM is loaded\n     *\n     * @return {void}\n     */\n    load() {\n        $html.addClass('dom-is-loaded');\n        $html.removeClass('dom-is-loading');\n        setTimeout(() => {\n            $html.addClass('dom-is-animated');\n        }, 1000)\n    }\n}\n","import { isArray } from './is';\n\nexport function addToArray ( array, value ) {\n    const index = array.indexOf( value );\n\n    if ( index === -1 ) {\n        array.push( value );\n    }\n}\n\nexport function arrayContains ( array, value ) {\n    for ( let i = 0, c = array.length; i < c; i++ ) {\n        if ( array[i] == value ) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nexport function arrayContentsMatch ( a, b ) {\n    let i;\n\n    if ( !isArray( a ) || !isArray( b ) ) {\n        return false;\n    }\n\n    if ( a.length !== b.length ) {\n        return false;\n    }\n\n    i = a.length;\n    while ( i-- ) {\n        if ( a[i] !== b[i] ) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\nexport function ensureArray ( x ) {\n    if ( typeof x === 'string' ) {\n        return [ x ];\n    }\n\n    if ( x === undefined ) {\n        return [];\n    }\n\n    return x;\n}\n\nexport function lastItem ( array ) {\n    return array[ array.length - 1 ];\n}\n\nexport function removeFromArray ( array, member ) {\n    if ( !array ) {\n        return;\n    }\n\n    const index = array.indexOf( member );\n\n    if ( index !== -1 ) {\n        array.splice( index, 1 );\n    }\n}\n\nexport function toArray ( arrayLike ) {\n    const array = [];\n    let i = arrayLike.length;\n    while ( i-- ) {\n        array[i] = arrayLike[i];\n    }\n\n    return array;\n}\n\nexport function findByKeyValue( array, key, value ) {\n    return array.filter(function( obj ) {\n        return obj[key] === value;\n    });\n}\n","export default function(func, wait, immediate) {\n    let timeout;\n    return function() {\n        const context = this;\n        const args = arguments;\n        const later = function() {\n            timeout = null;\n            if (!immediate) func.apply(context, args);\n        };\n        const callNow = immediate && !timeout;\n        clearTimeout(timeout);\n        timeout = setTimeout(later, wait);\n        if (callNow) func.apply(context, args);\n    };\n}\n","const APP_NAME     = 'Boilerplate';\nconst DATA_API_KEY = '.data-api';\n\nconst $document    = $(document);\nconst $window      = $(window);\nconst $html        = $(document.documentElement).removeClass('has-no-js').addClass('has-js');\nconst $body        = $(document.body);\nconst $barba       = $('#js-barba-wrapper');\n\nconst isDebug      = !!$html.data('debug');\n\nexport { APP_NAME, DATA_API_KEY, $document, $window, $html, $body, isDebug, $barba };\n","/**\n * @see  https://github.com/ractivejs/ractive/blob/dev/src/utils/html.js\n */\nexport function escapeHtml(str) {\n    return str\n        .replace(/&/g, '&amp;')\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;');\n}\n\n/**\n * Prepare HTML content that contains mustache characters for use with Ractive\n * @param  {string} str\n * @return {string}\n */\nexport function unescapeHtml(str) {\n    return str\n        .replace(/&lt;/g, '<')\n        .replace(/&gt;/g, '>')\n        .replace(/&amp;/g, '&');\n}\n\n/**\n * Get element data attributes\n * @param   {DOMElement}  node\n * @return  {Array}       data\n */\nexport function getNodeData(node) {\n    // All attributes\n    const attributes = node.attributes;\n\n    // Regex Pattern\n    const pattern = /^data\\-(.+)$/;\n\n    // Output\n    const data = {};\n\n    for (let i in attributes) {\n        if (!attributes[i]) {\n            continue;\n        }\n\n        // Attributes name (ex: data-module)\n        let name = attributes[i].name;\n\n        // This happens.\n        if (!name) {\n            continue;\n        }\n\n        let match = name.match(pattern);\n        if (!match) {\n            continue;\n        }\n\n        // If this throws an error, you have some\n        // serious problems in your HTML.\n        data[match[1]] = getData(node.getAttribute(name));\n    }\n\n    return data;\n}\n\nconst rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/;\n\n/**\n * Parse value to data type.\n *\n * @link   https://github.com/jquery/jquery/blob/3.1.1/src/data.js\n * @param  {string} data - A value to convert.\n * @return {mixed}  Returns the value in its natural data type.\n */\nexport function getData(data) {\n    if (data === 'true') {\n        return true;\n    }\n\n    if (data === 'false') {\n        return false;\n    }\n\n    if (data === 'null') {\n        return null;\n    }\n\n    // Only convert to a number if it doesn't change the string\n    if (data === +data+'') {\n        return +data;\n    }\n\n    if (rbrace.test( data )) {\n        return JSON.parse( data );\n    }\n\n    return data;\n}\n","const toString = Object.prototype.toString;\nconst arrayLikePattern = /^\\[object (?:Array|FileList)\\]$/;\n\n// thanks, http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/\nexport function isArray ( thing ) {\n    return toString.call( thing ) === '[object Array]';\n}\n\nexport function isArrayLike ( obj ) {\n    return arrayLikePattern.test( toString.call( obj ) );\n}\n\nexport function isEqual ( a, b ) {\n    if ( a === null && b === null ) {\n        return true;\n    }\n\n    if ( typeof a === 'object' || typeof b === 'object' ) {\n        return false;\n    }\n\n    return a === b;\n}\n\n// http://stackoverflow.com/questions/18082/validate-numbers-in-javascript-isnumeric\nexport function isNumeric ( thing ) {\n    return !isNaN( parseFloat( thing ) ) && isFinite( thing );\n}\n\nexport function isObject ( thing ) {\n    return ( thing && toString.call( thing ) === '[object Object]' );\n}\n\nexport function isFunction( thing ) {\n    const getType = {};\n    return thing && getType.toString.call(thing) === '[object Function]';\n}\n","/* jshint esnext: true */\nimport { isNumeric } from './is'\n\nlet isAnimating = false;\n\nconst defaults = {\n    easing: 'swing',\n    headerOffset: 60,\n    speed: 300\n};\n\n/**\n * scrollTo is a function that scrolls a container to an element's position within that controller\n * Uses jQuery's $.Deferred to allow using a callback on animation completion\n * @param   {object}  $element  A jQuery node\n * @param   {object}  options\n */\nexport function scrollTo($element, options) {\n    const deferred = $.Deferred();\n\n    // Drop everything if this ain't a jQuery object\n    if ($element instanceof jQuery && $element.length > 0) {\n\n        // Merging options\n        options = $.extend({}, defaults, (typeof options !== 'undefined' ? options : {}));\n\n        // Prevents accumulation of animations\n        if (isAnimating === false) {\n            isAnimating = true;\n\n            // Default container that we'll be scrolling\n            let $container = $('html, body');\n            let elementOffset = 0;\n\n            // Testing container in options for jQuery-ness\n            // If we're not using a custom container, we take the top document offset\n            // If we are, we use the elements position relative to the container\n            if (typeof options.$container !== 'undefined' && options.$container instanceof jQuery && options.$container.length > 0) {\n                $container = options.$container;\n\n                if (typeof options.scrollTop !== 'undefined' && isNumeric(options.scrollTop) && options.scrollTop !== 0) {\n                    scrollTop = options.scrollTop;\n                } else {\n                    scrollTop = $element.position().top - options.headerOffset;\n                }\n            } else {\n                if (typeof options.scrollTop !== 'undefined' && isNumeric(options.scrollTop) && options.scrollTop !== 0) {\n                    scrollTop = options.scrollTop;\n                } else {\n                    scrollTop = $element.offset().top - options.headerOffset;\n                }\n            }\n\n            $container.animate({\n                scrollTop: scrollTop\n            }, options.speed, options.easing, function() {\n                isAnimating = false;\n                deferred.resolve();\n            });\n        }\n    }\n\n    return deferred.promise();\n}\n","/* jshint esnext: true */\nimport { isFunction } from './is';\nimport { arrayContains, findByKeyValue, removeFromArray } from './array';\nimport { $document, $window, $html, $body } from './environment';\n\nconst CALLBACKS = {\n    hidden: [],\n    visible: []\n};\n\nconst ACTIONS = [\n    'addCallback',\n    'removeCallback'\n];\n\nconst STATES = [\n    'visible',\n    'hidden'\n];\n\nconst PREFIX = 'v-';\n\nlet UUID = 0;\n\n// Main event\n$document.on('visibilitychange', function(event) {\n    if (document.hidden) {\n        onDocumentChange('hidden');\n    } else {\n        onDocumentChange('visible');\n    }\n});\n\n/**\n * Add a callback\n * @param {string}   state\n * @param {function} callback\n * @return {string}  ident\n */\nfunction addCallback (state, options) {\n    let callback = options.callback || '';\n\n    if (!isFunction(callback)) {\n        console.warn('Callback is not a function');\n        return false;\n    }\n\n    let ident = PREFIX + UUID++;\n\n    CALLBACKS[state].push({\n        ident: ident,\n        callback: callback\n    });\n\n    return ident;\n}\n\n/**\n * Remove a callback\n * @param  {string}   state  Visible or hidden\n * @param  {string}   ident  Unique identifier\n * @return {boolean}         If operation was a success\n */\nfunction removeCallback (state, options) {\n    let ident = options.ident || '';\n\n    if (typeof(ident) === 'undefined' || ident === '') {\n        console.warn('Need ident to remove callback');\n        return false;\n    }\n\n    let index = findByKeyValue(CALLBACKS[state], 'ident', ident)[0];\n\n    // console.log(ident)\n    // console.log(CALLBACKS[state])\n\n    if (typeof(index) !== 'undefined') {\n        removeFromArray(CALLBACKS[state], index);\n        return true;\n    } else {\n        console.warn('Callback could not be found');\n        return false;\n    }\n}\n\n/**\n * When document state changes, trigger callbacks\n * @param  {string}  state  Visible or hidden\n */\nfunction onDocumentChange (state) {\n    let callbackArray = CALLBACKS[state];\n    let i = 0;\n    let len = callbackArray.length;\n\n    for (; i < len; i++) {\n        callbackArray[i].callback();\n    }\n}\n\n/**\n * Public facing API for adding and removing callbacks\n * @param   {object}           options  Options\n * @return  {boolean|integer}           Unique identifier for the callback or boolean indicating success or failure\n */\nfunction visibilityApi (options) {\n    let action = options.action || '';\n    let state = options.state || '';\n    let ret;\n\n    // Type and value checking\n    if (!arrayContains(ACTIONS, action)) {\n        console.warn('Action does not exist');\n        return false;\n    }\n    if (!arrayContains(STATES, state)) {\n        console.warn('State does not exist');\n        return false;\n    }\n\n    // @todo Magic call function pls\n    if (action === 'addCallback') {\n        ret = addCallback(state, options);\n    } else if (action === 'removeCallback') {\n        ret = removeCallback(state, options);\n    }\n\n    return ret;\n}\n\nexport { visibilityApi };\n"]} +},{"./array":10,"./environment":12,"./is":14}]},{},[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","assets/scripts/App.js","assets/scripts/globals.js","assets/scripts/modules.js","assets/scripts/modules/AbstractModule.js","assets/scripts/modules/Example.js","assets/scripts/transitions/BaseTransition.js","assets/scripts/transitions/CustomTransition.js","assets/scripts/transitions/TransitionManager.js","assets/scripts/transitions/transitions.js","assets/scripts/utils/array.js","assets/scripts/utils/debounce.js","assets/scripts/utils/environment.js","assets/scripts/utils/html.js","assets/scripts/utils/is.js","assets/scripts/utils/scrollTo.js","assets/scripts/utils/visibility.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/* jshint esnext: true */\nimport { APP_NAME, $document, $pjaxWrapper } from './utils/environment';\n\nimport globals from './globals';\n\nimport { arrayContains, removeFromArray } from './utils/array';\nimport { getNodeData } from './utils/html';\nimport { isFunction } from './utils/is';\n\n// Basic modules\nimport * as modules from './modules';\n\nconst MODULE_NAME = 'App';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nexport const EVENT = {\n    INIT_MODULES: `initModules.${EVENT_NAMESPACE}`,\n    INIT_SCOPED_MODULES: `initScopedModules.${EVENT_NAMESPACE}`,\n    DELETE_SCOPED_MODULES: `deleteScopedModules.${EVENT_NAMESPACE}`\n};\n\nclass App {\n    constructor() {\n        this.modules = modules;\n        this.currentModules = [];\n\n        $document.on(EVENT.INIT_MODULES, (event) => {\n            this.initGlobals(event.firstBlood)\n                .deleteModules(event)\n                .initModules(event);\n        });\n\n        $document.on(EVENT.INIT_SCOPED_MODULES, (event) => {\n            this.initModules(event);\n        });\n\n        $document.on(EVENT.DELETE_SCOPED_MODULES, (event) => {\n            this.deleteModules(event);\n        });\n    }\n\n    /**\n     * Destroy all existing modules or a specific scope of modules\n     * @param  {Object} event The event being triggered.\n     * @return {Object}       Self (allows chaining)\n     */\n    deleteModules(event) {\n        let destroyAll = true;\n        let moduleIds = [];\n\n        // Check for scope first\n        if (event.$scope instanceof jQuery && event.$scope.length > 0) {\n            // Modules within scope\n            const $modules = event.$scope.find('[data-module]');\n\n            // Determine their uids\n            moduleIds = $.makeArray($modules.map(function(index) {\n                return $modules.eq(index).data('uid');\n            }));\n\n            if (moduleIds.length > 0) {\n                destroyAll = false;\n            } else {\n                return this;\n            }\n        }\n\n        // Loop modules and destroying all of them, or specific ones\n        let i = this.currentModules.length;\n\n        while (i--) {\n            if (destroyAll || arrayContains(moduleIds, this.currentModules[i].uid)) {\n                removeFromArray(moduleIds, this.currentModules[i].uid);\n                this.currentModules[i].destroy();\n                this.currentModules.splice(i);\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Execute global functions and settings\n     * Allows you to initialize global modules only once if you need\n     * (ex.: when using Barba.js or SmoothState.js)\n     * @return {Object} Self (allows chaining)\n     */\n    initGlobals(firstBlood) {\n        globals(firstBlood);\n        return this;\n    }\n\n    /**\n     * Find modules and initialize them\n     * @param  {Object} event The event being triggered.\n     * @return {Object}       Self (allows chaining)\n     */\n    initModules(event) {\n        // Elements with module\n        let $moduleEls = [];\n\n        // If first blood, load all modules in the DOM\n        // If scoped, render elements with modules\n        // If Barba, load modules contained in Barba container\n        if (event.firstBlood) {\n            $moduleEls = $document.find('[data-module]');\n        } else if (event.$scope instanceof jQuery && event.$scope.length > 0) {\n            $moduleEls = event.$scope.find('[data-module]');\n        } else if (event.isPjax) {\n            $moduleEls = $pjaxWrapper.find('[data-module]');\n        }\n\n        // Loop through elements\n        let i = 0;\n        const elsLen = $moduleEls.length;\n\n        for (; i < elsLen; i++) {\n\n            // Current element\n            let el = $moduleEls[i];\n\n            // All data- attributes considered as options\n            let options = getNodeData(el);\n\n            // Add current DOM element and jQuery element\n            options.el = el;\n            options.$el = $moduleEls.eq(i);\n\n            // Module does exist at this point\n            let attr = options.module;\n\n            // Splitting modules found in the data-attribute\n            let moduleIdents = attr.split(/[,\\s]+/g);\n\n            // Loop modules\n            let j = 0;\n            let modulesLen = moduleIdents.length;\n\n            for (; j < modulesLen; j++) {\n                let moduleAttr = moduleIdents[j];\n\n                if (typeof this.modules[moduleAttr] === 'function') {\n                    let module = new this.modules[moduleAttr](options);\n                    this.currentModules.push(module);\n                    module.init();\n                }\n            }\n        }\n\n        return this;\n    }\n}\n\n// IIFE for loading the application\n// ==========================================================================\n(function() {\n    new App();\n    $document.triggerHandler({\n        type: EVENT.INIT_MODULES,\n        firstBlood: true\n    });\n})();\n","/* jshint esnext: true */\nimport TransitionManager from './transitions/TransitionManager';\n\nexport default function(firstBlood) {\n    svg4everybody();\n\n    if (firstBlood) {\n        const transitionManager = new TransitionManager();\n    }\n}\n","/* jshint esnext: true */\nexport {default as Example} from './modules/Example';\n","/* jshint esnext: true */\nlet uid = 0;\n\n/**\n * Abstract Module\n */\nexport default class {\n    constructor(options) {\n        this.$el = options.$el || null;\n        this.el  = options.el  || null;\n\n        // Generate a unique module identifier\n        this.uid = 'm-' + uid++;\n        // Use jQuery's data API to \"store it in the DOM\"\n        this.$el.data('uid', this.uid);\n    }\n\n    init() {}\n\n    destroy() {\n        if (this.$el) {\n            this.$el.removeData('uid')\n        }\n    }\n}\n","/* jshint esnext: true */\nimport { APP_NAME } from '../utils/environment';\nimport AbstractModule from './AbstractModule';\n\nconst MODULE_NAME = 'Example';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nconst EVENT = {\n    CLICK: `click.${EVENT_NAMESPACE}`\n};\n\nexport default class extends AbstractModule {\n    constructor(options) {\n        super(options);\n\n        // Declaration of properties\n        console.log('🔨 [module]:constructor - Example');\n\n    }\n\n    init() {\n        // Set events and such\n\n    }\n\n    destroy() {\n        console.log('❌ [module]:destroy - Example');\n        super.destroy();\n        this.$el.off(`.${EVENT_NAMESPACE}`);\n    }\n}\n","import { APP_NAME, $document, $html, $body,  isDebug, $pjaxWrapper } from '../utils/environment';\n\nconst MODULE_NAME = 'Transition';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nconst EVENT = {\n    CLICK: `click.${EVENT_NAMESPACE}`,\n    READYTOREMOVE: `readyToRemove.${EVENT_NAMESPACE}`,\n    READYTODESTROY: `readyToDestroy.${EVENT_NAMESPACE}`\n};\n\nexport default class {\n    constructor(options) {\n\n        this.options = options;\n        this.wrapper = options.wrapper;\n        this.overrideClass = options.overrideClass ? options.overrideClass : '';\n        this.clickedLink = options.clickedLink;\n\n    }\n\n    launch() {\n        if(isDebug) {\n            console.log(\"---- Launch transition 👊 -----\");\n        }\n\n        $html\n            .removeClass('dom-is-loaded dom-is-animated ')\n            .addClass(`dom-is-loading ${this.overrideClass}`);\n\n    }\n\n    hideView(oldView, newView) {\n        if(isDebug) {\n            console.log('----- ❌ [VIEW]:hide - ', oldView.getAttribute('data-template'));\n        }\n\n        // launch it at the end (animations...)\n        $document.triggerHandler({\n            type:EVENT.READYTOREMOVE,\n            oldView: oldView,\n            newView: newView\n        });\n\n    }\n\n\n    displayView(view) {\n\n        if(isDebug) {\n            console.log('----- ✅ [VIEW]:display :', view.getAttribute('data-template'));\n        }\n\n        $html.attr('data-template', view.getAttribute('data-template'));\n\n        setTimeout(() => {\n                \n            $html\n                .addClass('dom-is-loaded')\n                .removeClass('dom-is-loading');\n\n            setTimeout(() => {\n                $html\n                    .removeClass(this.overrideClass)\n                    .addClass('dom-is-animated');\n            }, 1000);\n\n            // launch it at the end (animations...)\n            $document.triggerHandler({\n                type:EVENT.READYTODESTROY\n            });\n\n        },1000);\n    }\n\n    \n    destroy() {\n        if(isDebug) {\n            console.log(\"---- ❌ [transition]:destroy -----\");\n        }\n    }\n}\n","import { APP_NAME, $document, $html, isDebug, $pjaxWrapper } from '../utils/environment';\nimport BaseTransition from './BaseTransition';\n\nconst MODULE_NAME = 'Transition';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nconst EVENT = {\n    CLICK: `click.${EVENT_NAMESPACE}`,\n    READYTOREMOVE: `readyToRemove.${EVENT_NAMESPACE}`,\n    READYTODISPLAY: `readyToDisplay.${EVENT_NAMESPACE}`,\n    READYTODESTROY: `readyToDestroy.${EVENT_NAMESPACE}`\n};\n\n\nexport default class extends BaseTransition{\n    constructor(options) {\n        super(options);\n\n        this.overrideClass = '-custom-transition';\n    }\n\n}\n","/* jshint esnext: true */\nimport { APP_NAME, $document, $html, isDebug, $pjaxWrapper } from '../utils/environment';\nimport { EVENT as APP_EVENT } from '../App';\n\n//List here all of your transitions\nimport * as transitions from './transitions';\n\nconst MODULE_NAME = 'Transition';\nconst EVENT_NAMESPACE = `${APP_NAME}.${MODULE_NAME}`;\n\nconst EVENT = {\n    CLICK: `click.${EVENT_NAMESPACE}`,\n    READYTOREMOVE: `readyToRemove.${EVENT_NAMESPACE}`,\n    READYTODESTROY: `readyToDestroy.${EVENT_NAMESPACE}`\n};\n\n/*\n\n@todo : \n\n- ✅ get data-transition on clicked link -> launch() and add switch(){}\n- ❌ add goto listener\n- ❌ add newPageReady functon with google analytics send (maybe pjax do that?)\n- ✅ add overrideClass system for all transitions\n- ✅ add base class manager like old DefaultTransition (dom-is-loaded, dom-is-loading etc..)\n\n\n\n======= SCHEMA =======\n\n[] : listener\n* : trigger event\n\n[pjax:send] -> (transition) launch()\n\n[pjax:switch] (= new view is loaded) -> (transition) hideView()-> hide animations & *readyToRemove\n\n[readyToRemove] -> remove() -> delete modules\n                            -> remove oldView from the DOM, and innerHTMl newView\n                            -> display()\n\ndisplay() -> (transition) displayView() -> display animations & *readyToRemove\n          -> init new modules\n\n[readyToRemove] -> reinit()\n\n*/\n\nexport default class {\n    constructor() {\n        \n\n        // jQuery ondomready\n        $(() => {\n            this.load();\n        });\n\n        this.transition = new transitions['BaseTransition']({\n            wrapper: this.wrapper\n        });\n\n        /*\n        ===== PJAX CONFIGURATION =====\n        */\n\n        this.containerClass = '.js-pjax-container';\n        this.wrapperId = 'js-pjax-wrapper';\n        this.noPjaxRequestClass = 'no-transition';\n        this.wrapper = document.getElementById(this.wrapperId);\n\n        this.options = {\n            debug: false,\n            cacheBust: false,\n            elements: [`a:not(.${this.noPjaxRequestClass})`,'form[action]'],\n            selectors: ['title',`${this.containerClass}`],\n            switches: {}\n        };\n        this.options.switches[this.containerClass] = (oldEl, newEl, options) => this.switch(oldEl, newEl, options)\n        this.pjax = new Pjax(this.options);\n\n        /*\n        ===== LISTENERS =====\n        */\n\n        document.addEventListener('pjax:send',(e) => this.send(e));\n\n\n        $document.on(EVENT.READYTOREMOVE,(event) => {\n            this.remove(event.oldView, event.newView);\n        });\n        $document.on(EVENT.READYTODESTROY,(event) => {\n            this.reinit();\n        });\n    }\n\n\n    /**\n     * (PJAX) Launch when pjax receive a request\n     * get & manage data-transition,init and launch it\n     * @param  {event}\n     * @return void\n     */\n    send(e) {\n        if(isDebug) {\n            console.log(\"---- Launch request 🙌 -----\");\n        }\n\n        let el = e.triggerElement;\n        \n        let transition = el.getAttribute('data-transition') ? el.getAttribute('data-transition') : 'BaseTransition';\n        $html.attr('data-transition',transition);\n\n        // options available : wrapper, overrideClass\n        this.transition = new transitions[transition]({\n            wrapper: this.wrapper,\n            clickedLink: el\n        });\n\n        this.transition.launch();\n\n    }\n\n    /**\n     * (PJAX) Launch when new page is loaded\n     * @param  {js dom element}, \n     * @param  {js dom element}\n     * @param  {options : pjax options}\n     * @return void\n     */\n    switch(oldView, newView, options) {\n        if(isDebug) {\n            console.log('---- Next view loaded 👌 -----');\n        }\n        this.transition.hideView(oldView, newView);\n\n        this.pjax.onSwitch();\n        \n    }\n\n    /**\n     * Launch when you trigger EVENT.READYTOREMOVE in your transition -> hideView(), at the end\n     * after oldView hidden, delete modules and launch this.display()\n     * @param  {js dom element}, \n     * @param  {js dom element}\n     * @return void\n     */\n    remove(oldView, newView) {\n\n        $document.triggerHandler({\n            type: APP_EVENT.DELETE_SCOPED_MODULES,\n            $scope: $pjaxWrapper\n        });\n\n        oldView.remove();\n\n        this.display(newView);\n    }\n\n    /**\n     * launch after this.remove()\n     * @param  {js dom element}, \n     * @return void\n     */\n    display(view) {\n        this.wrapper.innerHTML = view.outerHTML;\n\n        // Fetch any inline script elements.\n        const scripts = view.querySelectorAll('script.js-inline');\n\n        if (scripts instanceof window.NodeList) {\n            let i = 0;\n            let len = scripts.length;\n            for (; i < len; i++) {\n                eval(scripts[i].innerHTML);\n            }\n        }\n\n        $document.triggerHandler({\n            type: APP_EVENT.INIT_SCOPED_MODULES,\n            isPjax: true\n        });\n\n        this.transition.displayView(view);\n\n    }\n\n    /**\n     * Launch when you trigger EVENT.READYTODESTROY in your transition -> displayView(), at the end\n     * @return void\n     */\n    reinit() {\n        this.transition.destroy();\n        $html.attr('data-transition','');\n        this.transition = new transitions['BaseTransition']({\n            wrapper: this.wrapper\n        });\n    }\n\n    /**\n     * DOM is loaded\n     *\n     * @return {void}\n     */\n    load() {\n        $html.addClass('dom-is-loaded');\n        $html.removeClass('dom-is-loading');\n        setTimeout(() => {\n            $html.addClass('dom-is-animated');\n        }, 1000)\n    }\n}\n","export {default as BaseTransition} from './BaseTransition';\nexport {default as CustomTransition} from './CustomTransition';\n","import { isArray } from './is';\n\nexport function addToArray ( array, value ) {\n    const index = array.indexOf( value );\n\n    if ( index === -1 ) {\n        array.push( value );\n    }\n}\n\nexport function arrayContains ( array, value ) {\n    for ( let i = 0, c = array.length; i < c; i++ ) {\n        if ( array[i] == value ) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nexport function arrayContentsMatch ( a, b ) {\n    let i;\n\n    if ( !isArray( a ) || !isArray( b ) ) {\n        return false;\n    }\n\n    if ( a.length !== b.length ) {\n        return false;\n    }\n\n    i = a.length;\n    while ( i-- ) {\n        if ( a[i] !== b[i] ) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\nexport function ensureArray ( x ) {\n    if ( typeof x === 'string' ) {\n        return [ x ];\n    }\n\n    if ( x === undefined ) {\n        return [];\n    }\n\n    return x;\n}\n\nexport function lastItem ( array ) {\n    return array[ array.length - 1 ];\n}\n\nexport function removeFromArray ( array, member ) {\n    if ( !array ) {\n        return;\n    }\n\n    const index = array.indexOf( member );\n\n    if ( index !== -1 ) {\n        array.splice( index, 1 );\n    }\n}\n\nexport function toArray ( arrayLike ) {\n    const array = [];\n    let i = arrayLike.length;\n    while ( i-- ) {\n        array[i] = arrayLike[i];\n    }\n\n    return array;\n}\n\nexport function findByKeyValue( array, key, value ) {\n    return array.filter(function( obj ) {\n        return obj[key] === value;\n    });\n}\n\nexport function cloneArray( array ) {\n    return JSON.parse(JSON.stringify(array));\n}\n","export default function(func, wait, immediate) {\n    let timeout;\n    return function() {\n        const context = this;\n        const args = arguments;\n        const later = function() {\n            timeout = null;\n            if (!immediate) func.apply(context, args);\n        };\n        const callNow = immediate && !timeout;\n        clearTimeout(timeout);\n        timeout = setTimeout(later, wait);\n        if (callNow) func.apply(context, args);\n    };\n}\n","const APP_NAME     = 'Boilerplate';\nconst DATA_API_KEY = '.data-api';\n\nconst $document    = $(document);\nconst $window      = $(window);\nconst $html        = $(document.documentElement).removeClass('has-no-js').addClass('has-js');\nconst $body        = $(document.body);\nconst $pjaxWrapper = $('#js-pjax-wrapper');\n\nconst isDebug      = !!$html.data('debug');\n\nexport { APP_NAME, DATA_API_KEY, $document, $window, $html, $body, isDebug, $pjaxWrapper };\n","/**\n * @see  https://github.com/ractivejs/ractive/blob/dev/src/utils/html.js\n */\nexport function escapeHtml(str) {\n    return str\n        .replace(/&/g, '&amp;')\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;');\n}\n\n/**\n * Prepare HTML content that contains mustache characters for use with Ractive\n * @param  {string} str\n * @return {string}\n */\nexport function unescapeHtml(str) {\n    return str\n        .replace(/&lt;/g, '<')\n        .replace(/&gt;/g, '>')\n        .replace(/&amp;/g, '&');\n}\n\n/**\n * Get element data attributes\n * @param   {DOMElement}  node\n * @return  {Array}       data\n */\nexport function getNodeData(node) {\n    // All attributes\n    const attributes = node.attributes;\n\n    // Regex Pattern\n    const pattern = /^data\\-(.+)$/;\n\n    // Output\n    const data = {};\n\n    for (let i in attributes) {\n        if (!attributes[i]) {\n            continue;\n        }\n\n        // Attributes name (ex: data-module)\n        let name = attributes[i].name;\n\n        // This happens.\n        if (!name) {\n            continue;\n        }\n\n        let match = name.match(pattern);\n        if (!match) {\n            continue;\n        }\n\n        // If this throws an error, you have some\n        // serious problems in your HTML.\n        data[match[1]] = getData(node.getAttribute(name));\n    }\n\n    return data;\n}\n\nconst rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/;\n\n/**\n * Parse value to data type.\n *\n * @link   https://github.com/jquery/jquery/blob/3.1.1/src/data.js\n * @param  {string} data - A value to convert.\n * @return {mixed}  Returns the value in its natural data type.\n */\nexport function getData(data) {\n    if (data === 'true') {\n        return true;\n    }\n\n    if (data === 'false') {\n        return false;\n    }\n\n    if (data === 'null') {\n        return null;\n    }\n\n    // Only convert to a number if it doesn't change the string\n    if (data === +data+'') {\n        return +data;\n    }\n\n    if (rbrace.test( data )) {\n        return JSON.parse( data );\n    }\n\n    return data;\n}\n","const toString = Object.prototype.toString;\nconst arrayLikePattern = /^\\[object (?:Array|FileList)\\]$/;\n\n// thanks, http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/\nexport function isArray ( thing ) {\n    return toString.call( thing ) === '[object Array]';\n}\n\nexport function isArrayLike ( obj ) {\n    return arrayLikePattern.test( toString.call( obj ) );\n}\n\nexport function isEqual ( a, b ) {\n    if ( a === null && b === null ) {\n        return true;\n    }\n\n    if ( typeof a === 'object' || typeof b === 'object' ) {\n        return false;\n    }\n\n    return a === b;\n}\n\n// http://stackoverflow.com/questions/18082/validate-numbers-in-javascript-isnumeric\nexport function isNumeric ( thing ) {\n    return !isNaN( parseFloat( thing ) ) && isFinite( thing );\n}\n\nexport function isObject ( thing ) {\n    return ( thing && toString.call( thing ) === '[object Object]' );\n}\n\nexport function isFunction( thing ) {\n    const getType = {};\n    return thing && getType.toString.call(thing) === '[object Function]';\n}\n","/* jshint esnext: true */\nimport { isNumeric } from './is'\n\nlet isAnimating = false;\n\nconst defaults = {\n    easing: 'swing',\n    headerOffset: 60,\n    speed: 300\n};\n\n/**\n * scrollTo is a function that scrolls a container to an element's position within that controller\n * Uses jQuery's $.Deferred to allow using a callback on animation completion\n * @param   {object}  $element  A jQuery node\n * @param   {object}  options\n */\nexport function scrollTo($element, options) {\n    const deferred = $.Deferred();\n\n    // Drop everything if this ain't a jQuery object\n    if ($element instanceof jQuery && $element.length > 0) {\n\n        // Merging options\n        options = $.extend({}, defaults, (typeof options !== 'undefined' ? options : {}));\n\n        // Prevents accumulation of animations\n        if (isAnimating === false) {\n            isAnimating = true;\n\n            // Default container that we'll be scrolling\n            let $container = $('html, body');\n            let elementOffset = 0;\n\n            // Testing container in options for jQuery-ness\n            // If we're not using a custom container, we take the top document offset\n            // If we are, we use the elements position relative to the container\n            if (typeof options.$container !== 'undefined' && options.$container instanceof jQuery && options.$container.length > 0) {\n                $container = options.$container;\n\n                if (typeof options.scrollTop !== 'undefined' && isNumeric(options.scrollTop) && options.scrollTop !== 0) {\n                    scrollTop = options.scrollTop;\n                } else {\n                    scrollTop = $element.position().top - options.headerOffset;\n                }\n            } else {\n                if (typeof options.scrollTop !== 'undefined' && isNumeric(options.scrollTop) && options.scrollTop !== 0) {\n                    scrollTop = options.scrollTop;\n                } else {\n                    scrollTop = $element.offset().top - options.headerOffset;\n                }\n            }\n\n            $container.animate({\n                scrollTop: scrollTop\n            }, options.speed, options.easing, function() {\n                isAnimating = false;\n                deferred.resolve();\n            });\n        }\n    }\n\n    return deferred.promise();\n}\n","/* jshint esnext: true */\nimport { isFunction } from './is';\nimport { arrayContains, findByKeyValue, removeFromArray } from './array';\nimport { $document, $window, $html, $body } from './environment';\n\nconst CALLBACKS = {\n    hidden: [],\n    visible: []\n};\n\nconst ACTIONS = [\n    'addCallback',\n    'removeCallback'\n];\n\nconst STATES = [\n    'visible',\n    'hidden'\n];\n\nconst PREFIX = 'v-';\n\nlet UUID = 0;\n\n// Main event\n$document.on('visibilitychange', function(event) {\n    if (document.hidden) {\n        onDocumentChange('hidden');\n    } else {\n        onDocumentChange('visible');\n    }\n});\n\n/**\n * Add a callback\n * @param {string}   state\n * @param {function} callback\n * @return {string}  ident\n */\nfunction addCallback (state, options) {\n    let callback = options.callback || '';\n\n    if (!isFunction(callback)) {\n        console.warn('Callback is not a function');\n        return false;\n    }\n\n    let ident = PREFIX + UUID++;\n\n    CALLBACKS[state].push({\n        ident: ident,\n        callback: callback\n    });\n\n    return ident;\n}\n\n/**\n * Remove a callback\n * @param  {string}   state  Visible or hidden\n * @param  {string}   ident  Unique identifier\n * @return {boolean}         If operation was a success\n */\nfunction removeCallback (state, options) {\n    let ident = options.ident || '';\n\n    if (typeof(ident) === 'undefined' || ident === '') {\n        console.warn('Need ident to remove callback');\n        return false;\n    }\n\n    let index = findByKeyValue(CALLBACKS[state], 'ident', ident)[0];\n\n    // console.log(ident)\n    // console.log(CALLBACKS[state])\n\n    if (typeof(index) !== 'undefined') {\n        removeFromArray(CALLBACKS[state], index);\n        return true;\n    } else {\n        console.warn('Callback could not be found');\n        return false;\n    }\n}\n\n/**\n * When document state changes, trigger callbacks\n * @param  {string}  state  Visible or hidden\n */\nfunction onDocumentChange (state) {\n    let callbackArray = CALLBACKS[state];\n    let i = 0;\n    let len = callbackArray.length;\n\n    for (; i < len; i++) {\n        callbackArray[i].callback();\n    }\n}\n\n/**\n * Public facing API for adding and removing callbacks\n * @param   {object}           options  Options\n * @return  {boolean|integer}           Unique identifier for the callback or boolean indicating success or failure\n */\nfunction visibilityApi (options) {\n    let action = options.action || '';\n    let state = options.state || '';\n    let ret;\n\n    // Type and value checking\n    if (!arrayContains(ACTIONS, action)) {\n        console.warn('Action does not exist');\n        return false;\n    }\n    if (!arrayContains(STATES, state)) {\n        console.warn('State does not exist');\n        return false;\n    }\n\n    // @todo Magic call function pls\n    if (action === 'addCallback') {\n        ret = addCallback(state, options);\n    } else if (action === 'removeCallback') {\n        ret = removeCallback(state, options);\n    }\n\n    return ret;\n}\n\nexport { visibilityApi };\n"]} diff --git a/www/assets/scripts/vendors.js b/www/assets/scripts/vendors.js index c4f6e48..01450cd 100644 --- a/www/assets/scripts/vendors.js +++ b/www/assets/scripts/vendors.js @@ -1,1714 +1,788 @@ -/*! Dependencies for Locomotive Boilerplate - 2017-03-02 */ -(function webpackUniversalModuleDefinition(root, factory) { - if(typeof exports === 'object' && typeof module === 'object') - module.exports = factory(); - else if(typeof define === 'function' && define.amd) - define("Barba", [], factory); - else if(typeof exports === 'object') - exports["Barba"] = factory(); - else - root["Barba"] = factory(); -})(this, function() { -return /******/ (function(modules) { // webpackBootstrap -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) -/******/ return installedModules[moduleId].exports; -/******/ -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ exports: {}, -/******/ id: moduleId, -/******/ loaded: false -/******/ }; -/******/ -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ -/******/ // Flag the module as loaded -/******/ module.loaded = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ // expose the modules object (__webpack_modules__) -/******/ __webpack_require__.m = modules; -/******/ -/******/ // expose the module cache -/******/ __webpack_require__.c = installedModules; -/******/ -/******/ // __webpack_public_path__ -/******/ __webpack_require__.p = "http://localhost:8080/dist"; -/******/ -/******/ // Load entry module and return exports -/******/ return __webpack_require__(0); -/******/ }) -/************************************************************************/ -/******/ ([ -/* 0 */ -/***/ function(module, exports, __webpack_require__) { +/*! Dependencies for Locomotive Boilerplate - 2018-02-01 */ +!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Pjax=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= 0) { - item._idleTimeoutId = setTimeout(function onTimeout() { - if (item._onTimeout) - item._onTimeout(); - }, msecs); - } - }; - - // That's not how node.js implements it but the exposed api is the same. - exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { - var id = nextImmediateId++; - var args = arguments.length < 2 ? false : slice.call(arguments, 1); - - immediateIds[id] = true; - - nextTick(function onNextTick() { - if (immediateIds[id]) { - // fn.call() is faster so we optimize for the common use-case - // @see http://jsperf.com/call-apply-segu - if (args) { - fn.apply(null, args); - } else { - fn.call(null); - } - // Prevent ids from leaking - exports.clearImmediate(id); - } - }); - - return id; - }; - - exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { - delete immediateIds[id]; - }; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(2).setImmediate, __webpack_require__(2).clearImmediate)) + this.parseDOM(document) -/***/ }, -/* 3 */ -/***/ function(module, exports) { + on(window, "popstate", function(st) { + if (st.state) { + var opt = clone(this.options) + opt.url = st.state.url + opt.title = st.state.title + opt.history = false - // shim for using process in browser - - var process = module.exports = {}; - - // cached from whatever global is present so that test runners that stub it - // don't break things. But we need to wrap it in a try catch in case it is - // wrapped in strict mode code which doesn't define any globals. It's inside a - // function because try/catches deoptimize in certain engines. - - var cachedSetTimeout; - var cachedClearTimeout; - - (function () { - try { - cachedSetTimeout = setTimeout; - } catch (e) { - cachedSetTimeout = function () { - throw new Error('setTimeout is not defined'); - } - } - try { - cachedClearTimeout = clearTimeout; - } catch (e) { - cachedClearTimeout = function () { - throw new Error('clearTimeout is not defined'); - } - } - } ()) - var queue = []; - var draining = false; - var currentQueue; - var queueIndex = -1; - - function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } - } - - function drainQueue() { - if (draining) { - return; - } - var timeout = cachedSetTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - cachedClearTimeout(timeout); - } - - process.nextTick = function (fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - cachedSetTimeout(drainQueue, 0); - } - }; - - // v8 likes predictible objects - function Item(fun, array) { - this.fun = fun; - this.array = array; - } - Item.prototype.run = function () { - this.fun.apply(null, this.array); - }; - process.title = 'browser'; - process.browser = true; - process.env = {}; - process.argv = []; - process.version = ''; // empty string to avoid regexp issues - process.versions = {}; - - function noop() {} - - process.on = noop; - process.addListener = noop; - process.once = noop; - process.off = noop; - process.removeListener = noop; - process.removeAllListeners = noop; - process.emit = noop; - - process.binding = function (name) { - throw new Error('process.binding is not supported'); - }; - - process.cwd = function () { return '/' }; - process.chdir = function (dir) { - throw new Error('process.chdir is not supported'); - }; - process.umask = function() { return 0; }; + if (st.state.uid < this.lastUid) { + opt.backward = true + } + else { + opt.forward = true + } + this.lastUid = st.state.uid + + // @todo implement history cache here, based on uid + this.loadUrl(st.state.url, opt) + } + }.bind(this)) + } + +Pjax.prototype = { + log: _dereq_("./lib/proto/log.js"), + + getElements: _dereq_("./lib/proto/get-elements.js"), + + parseDOM: _dereq_("./lib/proto/parse-dom.js"), + + refresh: _dereq_("./lib/proto/refresh.js"), + + reload: _dereq_("./lib/reload.js"), + + attachLink: _dereq_("./lib/proto/attach-link.js"), + + forEachSelectors: function(cb, context, DOMcontext) { + return _dereq_("./lib/foreach-selectors.js").bind(this)(this.options.selectors, cb, context, DOMcontext) + }, + + switchSelectors: function(selectors, fromEl, toEl, options) { + return _dereq_("./lib/switches-selectors.js").bind(this)(this.options.switches, this.options.switchesOptions, selectors, fromEl, toEl, options) + }, + + // too much problem with the code below + // + it’s too dangerous +// switchFallback: function(fromEl, toEl) { +// this.switchSelectors(["head", "body"], fromEl, toEl) +// // execute script when DOM is like it should be +// Pjax.executeScripts(document.querySelector("head")) +// Pjax.executeScripts(document.querySelector("body")) +// } + + latestChance: function(href) { + window.location = href + }, + + onSwitch: function() { + trigger(window, "resize scroll") + }, + + loadContent: function(html, options) { + var tmpEl = document.implementation.createHTMLDocument() + + // parse HTML attributes to copy them + // since we are forced to use documentElement.innerHTML (outerHTML can't be used for ) + var htmlRegex = /]+>/gi + var htmlAttribsRegex = /\s?[a-z:]+(?:\=(?:\'|\")[^\'\">]+(?:\'|\"))*/gi + var matches = html.match(htmlRegex) + if (matches && matches.length) { + matches = matches[0].match(htmlAttribsRegex) + if (matches.length) { + matches.shift() + matches.forEach(function(htmlAttrib) { + var attr = htmlAttrib.trim().split("=") + if (attr.length === 1) { + tmpEl.documentElement.setAttribute(attr[0], true) + } + else { + tmpEl.documentElement.setAttribute(attr[0], attr[1].slice(1, -1)) + } + }) + } + } + + tmpEl.documentElement.innerHTML = html + this.log("load content", tmpEl.documentElement.attributes, tmpEl.documentElement.innerHTML.length) + + // Clear out any focused controls before inserting new page contents. + // we clear focus on non form elements + if (document.activeElement && !document.activeElement.value) { + try { + document.activeElement.blur() + } catch (e) { } + } + + // try { + this.switchSelectors(this.options.selectors, tmpEl, document, options) + + // FF bug: Won’t autofocus fields that are inserted via JS. + // This behavior is incorrect. So if theres no current focus, autofocus + // the last field. + // + // http://www.w3.org/html/wg/drafts/html/master/forms.html + var autofocusEl = Array.prototype.slice.call(document.querySelectorAll("[autofocus]")).pop() + if (autofocusEl && document.activeElement !== autofocusEl) { + autofocusEl.focus(); + } + + // execute scripts when DOM have been completely updated + this.options.selectors.forEach(function(selector) { + forEachEls(document.querySelectorAll(selector), function(el) { + executeScripts(el) + }) + }) + // } + // catch(e) { + // if (this.options.debug) { + // this.log("Pjax switch fail: ", e) + // } + // this.switchFallback(tmpEl, document) + // } + }, + + doRequest: _dereq_("./lib/request.js"), + + loadUrl: function(href, options) { + this.log("load href", href, options) + + trigger(document, "pjax:send", options); + + // Do the request + this.doRequest(href, function(html) { + // Fail if unable to load HTML via AJAX + if (html === false) { + trigger(document,"pjax:complete pjax:error", options) + + return + } + + // Clear out any focused controls before inserting new page contents. + document.activeElement.blur() + + try { + this.loadContent(html, options) + } + catch (e) { + if (!this.options.debug) { + if (console && console.error) { + console.error("Pjax switch fail: ", e) + } + this.latestChance(href) + return + } + else { + throw e + } + } + + if (options.history) { + if (this.firstrun) { + this.lastUid = this.maxUid = newUid() + this.firstrun = false + window.history.replaceState({ + url: window.location.href, + title: document.title, + uid: this.maxUid + }, + document.title) + } + + // Update browser history + this.lastUid = this.maxUid = newUid() + window.history.pushState({ + url: href, + title: options.title, + uid: this.maxUid + }, + options.title, + href) + } + + this.forEachSelectors(function(el) { + this.parseDOM(el) + }, this) + + // Fire Events + trigger(document,"pjax:complete pjax:success", options) + + options.analytics() + + // Scroll page to top on new page load + if (options.scrollTo !== false) { + if (options.scrollTo.length > 1) { + window.scrollTo(options.scrollTo[0], options.scrollTo[1]) + } + else { + window.scrollTo(0, options.scrollTo) + } + } + }.bind(this)) + } +} + +Pjax.isSupported = _dereq_("./lib/is-supported.js"); + +//arguably could do `if( require("./lib/is-supported.js")()) {` but that might be a little to simple +if (Pjax.isSupported()) { + module.exports = Pjax +} +// if there isn’t required browser functions, returning stupid api +else { + var stupidPjax = function() {} + for (var key in Pjax.prototype) { + if (Pjax.prototype.hasOwnProperty(key) && typeof Pjax.prototype[key] === "function") { + stupidPjax[key] = stupidPjax + } + } + + module.exports = stupidPjax +} + +},{"./lib/clone.js":2,"./lib/events/on.js":4,"./lib/events/trigger.js":5,"./lib/execute-scripts.js":6,"./lib/foreach-els.js":7,"./lib/foreach-selectors.js":8,"./lib/is-supported.js":9,"./lib/proto/attach-link.js":11,"./lib/proto/get-elements.js":12,"./lib/proto/log.js":13,"./lib/proto/parse-dom.js":14,"./lib/proto/parse-options.js":16,"./lib/proto/refresh.js":17,"./lib/reload.js":18,"./lib/request.js":19,"./lib/switches-selectors.js":20,"./lib/uniqueid.js":22}],2:[function(_dereq_,module,exports){ +module.exports = function(obj) { + if (null === obj || "object" != typeof obj) { + return obj + } + var copy = obj.constructor() + for (var attr in obj) { + if (obj.hasOwnProperty(attr)) { + copy[attr] = obj[attr] + } + } + return copy +} + +},{}],3:[function(_dereq_,module,exports){ +module.exports = function(el) { + // console.log("going to execute script", el) + + var code = (el.text || el.textContent || el.innerHTML || "") + var head = document.querySelector("head") || document.documentElement + var script = document.createElement("script") + + if (code.match("document.write")) { + if (console && console.log) { + console.log("Script contains document.write. Can’t be executed correctly. Code skipped ", el) + } + return false + } + + script.type = "text/javascript" + try { + script.appendChild(document.createTextNode(code)) + } + catch (e) { + // old IEs have funky script nodes + script.text = code + } + + // execute + head.insertBefore(script, head.firstChild) + head.removeChild(script) // avoid pollution + + return true +} + +},{}],4:[function(_dereq_,module,exports){ +var forEachEls = _dereq_("../foreach-els") + +module.exports = function(els, events, listener, useCapture) { + events = (typeof events === "string" ? events.split(" ") : events) + + events.forEach(function(e) { + forEachEls(els, function(el) { + el.addEventListener(e, listener, useCapture) + }) + }) +} + +},{"../foreach-els":7}],5:[function(_dereq_,module,exports){ +var forEachEls = _dereq_("../foreach-els") + +module.exports = function(els, events, opts) { + events = (typeof events === "string" ? events.split(" ") : events) + + events.forEach(function(e) { + var event // = new CustomEvent(e) // doesn't everywhere yet + event = document.createEvent("HTMLEvents") + event.initEvent(e, true, true) + event.eventName = e + if (opts) { + Object.keys(opts).forEach(function(key) { + event[key] = opts[key] + }) + } + + forEachEls(els, function(el) { + var domFix = false + if (!el.parentNode && el !== document && el !== window) { + // THANKS YOU IE (9/10//11 concerned) + // dispatchEvent doesn't work if element is not in the dom + domFix = true + document.body.appendChild(el) + } + el.dispatchEvent(event) + if (domFix) { + el.parentNode.removeChild(el) + } + }) + }) +} + +},{"../foreach-els":7}],6:[function(_dereq_,module,exports){ +var forEachEls = _dereq_("./foreach-els") +var evalScript = _dereq_("./eval-script") +// Finds and executes scripts (used for newly added elements) +// Needed since innerHTML does not run scripts +module.exports = function(el) { + // console.log("going to execute scripts for ", el) + forEachEls(el.querySelectorAll("script"), function(script) { + if (!script.type || script.type.toLowerCase() === "text/javascript") { + if (script.parentNode) { + script.parentNode.removeChild(script) + } + evalScript(script) + } + }) +} + +},{"./eval-script":3,"./foreach-els":7}],7:[function(_dereq_,module,exports){ +/* global HTMLCollection: true */ + +module.exports = function(els, fn, context) { + if (els instanceof HTMLCollection || els instanceof NodeList || els instanceof Array) { + return Array.prototype.forEach.call(els, fn, context) + } + // assume simple dom element + return fn.call(context, els) +} + +},{}],8:[function(_dereq_,module,exports){ +var forEachEls = _dereq_("./foreach-els") + +module.exports = function(selectors, cb, context, DOMcontext) { + DOMcontext = DOMcontext || document + selectors.forEach(function(selector) { + forEachEls(DOMcontext.querySelectorAll(selector), cb, context) + }) +} + +},{"./foreach-els":7}],9:[function(_dereq_,module,exports){ +module.exports = function() { + // Borrowed wholesale from https://github.com/defunkt/jquery-pjax + return window.history && + window.history.pushState && + window.history.replaceState && + // pushState isn’t reliable on iOS until 5. + !navigator.userAgent.match(/((iPod|iPhone|iPad).+\bOS\s+[1-4]\D|WebApps\/.+CFNetwork)/) +} + +},{}],10:[function(_dereq_,module,exports){ +if (!Function.prototype.bind) { + Function.prototype.bind = function(oThis) { + if (typeof this !== "function") { + // closest thing possible to the ECMAScript 5 internal IsCallable function + throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable") + } + + var aArgs = Array.prototype.slice.call(arguments, 1) + var that = this + var Fnoop = function() {} + var fBound = function() { + return that.apply(this instanceof Fnoop && oThis ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments))) + } + + Fnoop.prototype = this.prototype + fBound.prototype = new Fnoop() + + return fBound + } +} + +},{}],11:[function(_dereq_,module,exports){ +_dereq_("../polyfills/Function.prototype.bind") + +var on = _dereq_("../events/on") +var clone = _dereq_("../clone") + +var attrClick = "data-pjax-click-state" +var attrKey = "data-pjax-keyup-state" + +var linkAction = function(el, event) { + // Don’t break browser special behavior on links (like page in new window) + if (event.which > 1 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) { + el.setAttribute(attrClick, "modifier") + return + } + + // we do test on href now to prevent unexpected behavior if for some reason + // user have href that can be dynamically updated + + // Ignore external links. + if (el.protocol !== window.location.protocol || el.host !== window.location.host) { + el.setAttribute(attrClick, "external") + return + } + + // Ignore click if we are on an anchor on the same page + if (el.pathname === window.location.pathname && el.hash.length > 0) { + el.setAttribute(attrClick, "anchor-present") + return + } + + // Ignore anchors on the same page (keep native behavior) + if (el.hash && el.href.replace(el.hash, "") === window.location.href.replace(location.hash, "")) { + el.setAttribute(attrClick, "anchor") + return + } + + // Ignore empty anchor "foo.html#" + if (el.href === window.location.href.split("#")[0] + "#") { + el.setAttribute(attrClick, "anchor-empty") + return + } + + event.preventDefault() + + // don’t do "nothing" if user try to reload the page by clicking the same link twice + if ( + this.options.currentUrlFullReload && + el.href === window.location.href.split("#")[0] + ) { + el.setAttribute(attrClick, "reload") + this.reload() + return + } + + el.setAttribute(attrClick, "load") + this.loadUrl(el.href, clone(this.options)) +} + +var isDefaultPrevented = function(event) { + return event.defaultPrevented || event.returnValue === false; +} + +module.exports = function(el) { + var that = this + + on(el, "click", function(event) { + if (isDefaultPrevented(event)) { + return + } + + linkAction.call(that, el, event) + }) + + on(el, "keyup", function(event) { + if (isDefaultPrevented(event)) { + return + } + + // Don’t break browser special behavior on links (like page in new window) + if (event.which > 1 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) { + el.setAttribute(attrKey, "modifier") + return + } + + if (event.keyCode == 13) { + linkAction.call(that, el, event) + } + }.bind(this)) +} + +},{"../clone":2,"../events/on":4,"../polyfills/Function.prototype.bind":10}],12:[function(_dereq_,module,exports){ +module.exports = function(el) { + return el.querySelectorAll(this.options.elements) +} + +},{}],13:[function(_dereq_,module,exports){ +module.exports = function() { + if (this.options.debug && console) { + if (typeof console.log === "function") { + console.log.apply(console, arguments); + } + // ie is weird + else if (console.log) { + console.log(arguments); + } + } +} + +},{}],14:[function(_dereq_,module,exports){ +var forEachEls = _dereq_("../foreach-els") + +var parseElement = _dereq_("./parse-element") + +module.exports = function(el) { + forEachEls(this.getElements(el), parseElement, this) +} + +},{"../foreach-els":7,"./parse-element":15}],15:[function(_dereq_,module,exports){ +module.exports = function(el) { + switch (el.tagName.toLowerCase()) { + case "a": + // only attach link if el does not already have link attached + if (!el.hasAttribute('data-pjax-click-state')) { + this.attachLink(el) + } + break + + case "form": + throw "Pjax doesnt support
yet." + break + + default: + throw "Pjax can only be applied on or submit" + } +} + +},{}],16:[function(_dereq_,module,exports){ +/* global _gaq: true, ga: true */ + +module.exports = function(options){ + this.options = options + this.options.elements = this.options.elements || "a[href], form[action]" + this.options.selectors = this.options.selectors || ["title", ".js-Pjax"] + this.options.switches = this.options.switches || {} + this.options.switchesOptions = this.options.switchesOptions || {} + this.options.history = this.options.history || true + this.options.analytics = this.options.analytics || function() { + // options.backward or options.foward can be true or undefined + // by default, we do track back/foward hit + // https://productforums.google.com/forum/#!topic/analytics/WVwMDjLhXYk + if (window._gaq) { + _gaq.push(["_trackPageview"]) + } + if (window.ga) { + ga("send", "pageview", {page: location.pathname, title: document.title}) + } + } + this.options.scrollTo = (typeof this.options.scrollTo === 'undefined') ? 0 : this.options.scrollTo; + this.options.cacheBust = (typeof this.options.cacheBust === 'undefined') ? true : this.options.cacheBust + this.options.debug = this.options.debug || false + + // we can’t replace body.outerHTML or head.outerHTML + // it create a bug where new body or new head are created in the dom + // if you set head.outerHTML, a new body tag is appended, so the dom get 2 body + // & it break the switchFallback which replace head & body + if (!this.options.switches.head) { + this.options.switches.head = this.switchElementsAlt + } + if (!this.options.switches.body) { + this.options.switches.body = this.switchElementsAlt + } + if (typeof options.analytics !== "function") { + options.analytics = function() {} + } +} +},{}],17:[function(_dereq_,module,exports){ +module.exports = function(el) { + this.parseDOM(el || document) +} + +},{}],18:[function(_dereq_,module,exports){ +module.exports = function() { + window.location.reload() +} + +},{}],19:[function(_dereq_,module,exports){ +module.exports = function(location, callback) { + var request = new XMLHttpRequest() + + request.onreadystatechange = function() { + if (request.readyState === 4) { + if (request.status === 200) { + callback(request.responseText, request) + } + else { + callback(null, request) + } + } + } + + // Add a timestamp as part of the query string if cache busting is enabled + if (this.options.cacheBust) { + location += (!/[?&]/.test(location) ? "?" : "&") + new Date().getTime() + } + + request.open("GET", location, true) + request.setRequestHeader("X-Requested-With", "XMLHttpRequest") + request.send(null) + return request +} + +},{}],20:[function(_dereq_,module,exports){ +var forEachEls = _dereq_("./foreach-els") + +var defaultSwitches = _dereq_("./switches") + +module.exports = function(switches, switchesOptions, selectors, fromEl, toEl, options) { + selectors.forEach(function(selector) { + var newEls = fromEl.querySelectorAll(selector) + var oldEls = toEl.querySelectorAll(selector) + if (this.log) { + this.log("Pjax switch", selector, newEls, oldEls) + } + if (newEls.length !== oldEls.length) { + // forEachEls(newEls, function(el) { + // this.log("newEl", el, el.outerHTML) + // }, this) + // forEachEls(oldEls, function(el) { + // this.log("oldEl", el, el.outerHTML) + // }, this) + throw "DOM doesn’t look the same on new loaded page: ’" + selector + "’ - new " + newEls.length + ", old " + oldEls.length + } + + forEachEls(newEls, function(newEl, i) { + var oldEl = oldEls[i] + if (this.log) { + this.log("newEl", newEl, "oldEl", oldEl) + } + if (switches[selector]) { + switches[selector].bind(this)(oldEl, newEl, options, switchesOptions[selector]) + } + else { + defaultSwitches.outerHTML.bind(this)(oldEl, newEl, options) + } + }, this) + }, this) +} + +},{"./foreach-els":7,"./switches":21}],21:[function(_dereq_,module,exports){ +var on = _dereq_("./events/on.js") +// var off = require("./lib/events/on.js") +// var trigger = require("./lib/events/trigger.js") -/***/ }, -/* 4 */ -/***/ function(module, exports, __webpack_require__) { +module.exports = { + outerHTML: function(oldEl, newEl) { + oldEl.outerHTML = newEl.outerHTML + this.onSwitch() + }, - var Utils = __webpack_require__(5); - - /** - * BaseTransition to extend - * - * @namespace Barba.BaseTransition - * @type {Object} - */ - var BaseTransition = { - /** - * @memberOf Barba.BaseTransition - * @type {HTMLElement} - */ - oldContainer: undefined, - - /** - * @memberOf Barba.BaseTransition - * @type {HTMLElement} - */ - newContainer: undefined, - - /** - * @memberOf Barba.BaseTransition - * @type {Promise} - */ - newContainerLoading: undefined, - - /** - * Helper to extend the object - * - * @memberOf Barba.BaseTransition - * @param {Object} newObject - * @return {Object} newInheritObject - */ - extend: function(obj){ - return Utils.extend(this, obj); - }, - - /** - * This function is called from Pjax module to initialize - * the transition. - * - * @memberOf Barba.BaseTransition - * @private - * @param {HTMLElement} oldContainer - * @param {Promise} newContainer - * @return {Promise} - */ - init: function(oldContainer, newContainer) { - var _this = this; - - this.oldContainer = oldContainer; - this._newContainerPromise = newContainer; - - this.deferred = Utils.deferred(); - this.newContainerReady = Utils.deferred(); - this.newContainerLoading = this.newContainerReady.promise; - - this.start(); - - this._newContainerPromise.then(function(newContainer) { - _this.newContainer = newContainer; - _this.newContainerReady.resolve(); - }); - - return this.deferred.promise; - }, - - /** - * This function needs to be called as soon the Transition is finished - * - * @memberOf Barba.BaseTransition - */ - done: function() { - this.oldContainer.parentNode.removeChild(this.oldContainer); - this.newContainer.style.visibility = 'visible'; - this.deferred.resolve(); - }, - - /** - * Constructor for your Transition - * - * @memberOf Barba.BaseTransition - * @abstract - */ - start: function() {}, - }; - - module.exports = BaseTransition; + innerHTML: function(oldEl, newEl) { + oldEl.innerHTML = newEl.innerHTML + oldEl.className = newEl.className + this.onSwitch() + }, + sideBySide: function(oldEl, newEl, options, switchOptions) { + var forEach = Array.prototype.forEach + var elsToRemove = [] + var elsToAdd = [] + var fragToAppend = document.createDocumentFragment() + // height transition are shitty on safari + // so commented for now (until I found something ?) + // var relevantHeight = 0 + var animationEventNames = "animationend webkitAnimationEnd MSAnimationEnd oanimationend" + var animatedElsNumber = 0 + var sexyAnimationEnd = function(e) { + if (e.target != e.currentTarget) { + // end triggered by an animation on a child + return + } -/***/ }, -/* 5 */ -/***/ function(module, exports) { + animatedElsNumber-- + if (animatedElsNumber <= 0 && elsToRemove) { + elsToRemove.forEach(function(el) { + // browsing quickly can make the el + // already removed by last page update ? + if (el.parentNode) { + el.parentNode.removeChild(el) + } + }) - /** - * Just an object with some helpful functions - * - * @type {Object} - * @namespace Barba.Utils - */ - var Utils = { - /** - * Return the current url - * - * @memberOf Barba.Utils - * @return {String} currentUrl - */ - getCurrentUrl: function() { - return window.location.protocol + '//' + - window.location.host + - window.location.pathname + - window.location.search; - }, - - /** - * Given an url, return it without the hash - * - * @memberOf Barba.Utils - * @private - * @param {String} url - * @return {String} newCleanUrl - */ - cleanLink: function(url) { - return url.replace(/#.*/, ''); - }, - - /** - * Time in millisecond after the xhr request goes in timeout - * - * @memberOf Barba.Utils - * @type {Number} - * @default - */ - xhrTimeout: 5000, - - /** - * Start an XMLHttpRequest() and return a Promise - * - * @memberOf Barba.Utils - * @param {String} url - * @return {Promise} - */ - xhr: function(url) { - var deferred = this.deferred(); - var req = new XMLHttpRequest(); - - req.onreadystatechange = function() { - if (req.readyState === 4) { - if (req.status === 200) { - return deferred.resolve(req.responseText); - } else { - return deferred.reject(new Error('xhr: HTTP code is not 200')); - } - } - }; - - req.ontimeout = function() { - return deferred.reject(new Error('xhr: Timeout exceeded')); - }; - - req.open('GET', url); - req.timeout = this.xhrTimeout; - req.setRequestHeader('x-barba', 'yes'); - req.send(); - - return deferred.promise; - }, - - /** - * Get obj and props and return a new object with the property merged - * - * @memberOf Barba.Utils - * @param {object} obj - * @param {object} props - * @return {object} - */ - extend: function(obj, props) { - var newObj = Object.create(obj); - - for(var prop in props) { - if(props.hasOwnProperty(prop)) { - newObj[prop] = props[prop]; - } - } - - return newObj; - }, - - /** - * Return a new "Deferred" object - * https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Deferred - * - * @memberOf Barba.Utils - * @return {Deferred} - */ - deferred: function() { - return new function() { - this.resolve = null; - this.reject = null; - - this.promise = new Promise(function(resolve, reject) { - this.resolve = resolve; - this.reject = reject; - }.bind(this)); - }; - }, - - /** - * Return the port number normalized, eventually you can pass a string to be normalized. - * - * @memberOf Barba.Utils - * @private - * @param {String} p - * @return {Int} port - */ - getPort: function(p) { - var port = typeof p !== 'undefined' ? p : window.location.port; - var protocol = window.location.protocol; - - if (port != '') - return parseInt(port); - - if (protocol === 'http:') - return 80; - - if (protocol === 'https:') - return 443; - } - }; - - module.exports = Utils; + elsToAdd.forEach(function(el) { + el.className = el.className.replace(el.getAttribute("data-pjax-classes"), "") + el.removeAttribute("data-pjax-classes") + // Pjax.off(el, animationEventNames, sexyAnimationEnd, true) + }) + elsToAdd = null // free memory + elsToRemove = null // free memory -/***/ }, -/* 6 */ -/***/ function(module, exports, __webpack_require__) { + // assume the height is now useless (avoid bug since there is overflow hidden on the parent) + // oldEl.style.height = "auto" - var Dispatcher = __webpack_require__(7); - var Utils = __webpack_require__(5); - - /** - * BaseView to be extended - * - * @namespace Barba.BaseView - * @type {Object} - */ - var BaseView = { - /** - * Namespace of the view. - * (need to be associated with the data-namespace of the container) - * - * @memberOf Barba.BaseView - * @type {String} - */ - namespace: null, - - /** - * Helper to extend the object - * - * @memberOf Barba.BaseView - * @param {Object} newObject - * @return {Object} newInheritObject - */ - extend: function(obj){ - return Utils.extend(this, obj); - }, - - /** - * Init the view. - * P.S. Is suggested to init the view before starting Barba.Pjax.start(), - * in this way .onEnter() and .onEnterCompleted() will be fired for the current - * container when the page is loaded. - * - * @memberOf Barba.BaseView - */ - init: function() { - var _this = this; - - Dispatcher.on('initStateChange', - function(newStatus, oldStatus) { - if (oldStatus && oldStatus.namespace === _this.namespace) - _this.onLeave(); - } - ); - - Dispatcher.on('newPageReady', - function(newStatus, oldStatus, container) { - _this.container = container; - - if (newStatus.namespace === _this.namespace) - _this.onEnter(); - } - ); - - Dispatcher.on('transitionCompleted', - function(newStatus, oldStatus) { - if (newStatus.namespace === _this.namespace) - _this.onEnterCompleted(); - - if (oldStatus && oldStatus.namespace === _this.namespace) - _this.onLeaveCompleted(); - } - ); - }, - - /** - * This function will be fired when the container - * is ready and attached to the DOM. - * - * @memberOf Barba.BaseView - * @abstract - */ - onEnter: function() {}, - - /** - * This function will be fired when the transition - * to this container has just finished. - * - * @memberOf Barba.BaseView - * @abstract - */ - onEnterCompleted: function() {}, - - /** - * This function will be fired when the transition - * to a new container has just started. - * - * @memberOf Barba.BaseView - * @abstract - */ - onLeave: function() {}, - - /** - * This function will be fired when the container - * has just been removed from the DOM. - * - * @memberOf Barba.BaseView - * @abstract - */ - onLeaveCompleted: function() {} - } - - module.exports = BaseView; + // this is to trigger some repaint (example: picturefill) + this.onSwitch() + // Pjax.trigger(window, "scroll") + } + }.bind(this) + // Force height to be able to trigger css animation + // here we get the relevant height + // oldEl.parentNode.appendChild(newEl) + // relevantHeight = newEl.getBoundingClientRect().height + // oldEl.parentNode.removeChild(newEl) + // oldEl.style.height = oldEl.getBoundingClientRect().height + "px" -/***/ }, -/* 7 */ -/***/ function(module, exports) { + switchOptions = switchOptions || {} - /** - * Little Dispatcher inspired by MicroEvent.js - * - * @namespace Barba.Dispatcher - * @type {Object} - */ - var Dispatcher = { - /** - * Object that keeps all the events - * - * @memberOf Barba.Dispatcher - * @readOnly - * @type {Object} - */ - events: {}, - - /** - * Bind a callback to an event - * - * @memberOf Barba.Dispatcher - * @param {String} eventName - * @param {Function} function - */ - on: function(e, f) { - this.events[e] = this.events[e] || []; - this.events[e].push(f); - }, - - /** - * Unbind event - * - * @memberOf Barba.Dispatcher - * @param {String} eventName - * @param {Function} function - */ - off: function(e, f) { - if(e in this.events === false) - return; - - this.events[e].splice(this.events[e].indexOf(f), 1); - }, - - /** - * Fire the event running all the event associated to it - * - * @memberOf Barba.Dispatcher - * @param {String} eventName - * @param {...*} args - */ - trigger: function(e) {//e, ...args - if (e in this.events === false) - return; - - for(var i = 0; i < this.events[e].length; i++){ - this.events[e][i].apply(this, Array.prototype.slice.call(arguments, 1)); - } - } - }; - - module.exports = Dispatcher; + forEach.call(oldEl.childNodes, function(el) { + elsToRemove.push(el) + if (el.classList && !el.classList.contains("js-Pjax-remove")) { + // for fast switch, clean element that just have been added, & not cleaned yet. + if (el.hasAttribute("data-pjax-classes")) { + el.className = el.className.replace(el.getAttribute("data-pjax-classes"), "") + el.removeAttribute("data-pjax-classes") + } + el.classList.add("js-Pjax-remove") + if (switchOptions.callbacks && switchOptions.callbacks.removeElement) { + switchOptions.callbacks.removeElement(el) + } + if (switchOptions.classNames) { + el.className += " " + switchOptions.classNames.remove + " " + (options.backward ? switchOptions.classNames.backward : switchOptions.classNames.forward) + } + animatedElsNumber++ + on(el, animationEventNames, sexyAnimationEnd, true) + } + }) + forEach.call(newEl.childNodes, function(el) { + if (el.classList) { + var addClasses = "" + if (switchOptions.classNames) { + addClasses = " js-Pjax-add " + switchOptions.classNames.add + " " + (options.backward ? switchOptions.classNames.forward : switchOptions.classNames.backward) + } + if (switchOptions.callbacks && switchOptions.callbacks.addElement) { + switchOptions.callbacks.addElement(el) + } + el.className += addClasses + el.setAttribute("data-pjax-classes", addClasses) + elsToAdd.push(el) + fragToAppend.appendChild(el) + animatedElsNumber++ + on(el, animationEventNames, sexyAnimationEnd, true) + } + }) -/***/ }, -/* 8 */ -/***/ function(module, exports, __webpack_require__) { + // pass all className of the parent + oldEl.className = newEl.className + oldEl.appendChild(fragToAppend) - var Utils = __webpack_require__(5); - - /** - * BaseCache it's a simple static cache - * - * @namespace Barba.BaseCache - * @type {Object} - */ - var BaseCache = { - /** - * The Object that keeps all the key value information - * - * @memberOf Barba.BaseCache - * @type {Object} - */ - data: {}, - - /** - * Helper to extend this object - * - * @memberOf Barba.BaseCache - * @private - * @param {Object} newObject - * @return {Object} newInheritObject - */ - extend: function(obj) { - return Utils.extend(this, obj); - }, - - /** - * Set a key and value data, mainly Barba is going to save promises - * - * @memberOf Barba.BaseCache - * @param {String} key - * @param {*} value - */ - set: function(key, val) { - this.data[key] = val; - }, - - /** - * Retrieve the data using the key - * - * @memberOf Barba.BaseCache - * @param {String} key - * @return {*} - */ - get: function(key) { - return this.data[key]; - }, - - /** - * Flush the cache - * - * @memberOf Barba.BaseCache - */ - reset: function() { - this.data = {}; - } - }; - - module.exports = BaseCache; + // oldEl.style.height = relevantHeight + "px" + } +} +},{"./events/on.js":4}],22:[function(_dereq_,module,exports){ +module.exports = (function() { + var counter = 0 + return function() { + var id = ("pjax" + (new Date().getTime())) + "_" + counter + counter++ + return id + } +})() -/***/ }, -/* 9 */ -/***/ function(module, exports) { - - /** - * HistoryManager helps to keep track of the navigation - * - * @namespace Barba.HistoryManager - * @type {Object} - */ - var HistoryManager = { - /** - * Keep track of the status in historic order - * - * @memberOf Barba.HistoryManager - * @readOnly - * @type {Array} - */ - history: [], - - /** - * Add a new set of url and namespace - * - * @memberOf Barba.HistoryManager - * @param {String} url - * @param {String} namespace - * @private - */ - add: function(url, namespace) { - if (!namespace) - namespace = undefined; - - this.history.push({ - url: url, - namespace: namespace - }); - }, - - /** - * Return information about the current status - * - * @memberOf Barba.HistoryManager - * @return {Object} - */ - currentStatus: function() { - return this.history[this.history.length - 1]; - }, - - /** - * Return information about the previous status - * - * @memberOf Barba.HistoryManager - * @return {Object} - */ - prevStatus: function() { - var history = this.history; - - if (history.length < 2) - return null; - - return history[history.length - 2]; - } - }; - - module.exports = HistoryManager; - - -/***/ }, -/* 10 */ -/***/ function(module, exports, __webpack_require__) { - - var Utils = __webpack_require__(5); - var Dispatcher = __webpack_require__(7); - var HideShowTransition = __webpack_require__(11); - var BaseCache = __webpack_require__(8); - - var HistoryManager = __webpack_require__(9); - var Dom = __webpack_require__(12); - - /** - * Pjax is a static object with main function - * - * @namespace Barba.Pjax - * @borrows Dom as Dom - * @type {Object} - */ - var Pjax = { - Dom: Dom, - History: HistoryManager, - Cache: BaseCache, - - /** - * Indicate wether or not use the cache - * - * @memberOf Barba.Pjax - * @type {Boolean} - * @default - */ - cacheEnabled: true, - - /** - * Indicate if there is an animation in progress - * - * @memberOf Barba.Pjax - * @readOnly - * @type {Boolean} - */ - transitionProgress: false, - - /** - * Class name used to ignore links - * - * @memberOf Barba.Pjax - * @type {String} - * @default - */ - ignoreClassLink: 'no-barba', - - /** - * Function to be called to start Pjax - * - * @memberOf Barba.Pjax - */ - start: function() { - this.init(); - }, - - /** - * Init the events - * - * @memberOf Barba.Pjax - * @private - */ - init: function() { - var container = this.Dom.getContainer(); - var wrapper = this.Dom.getWrapper(); - - wrapper.setAttribute('aria-live', 'polite'); - - this.History.add( - this.getCurrentUrl(), - this.Dom.getNamespace(container) - ); - - //Fire for the current view. - Dispatcher.trigger('initStateChange', this.History.currentStatus()); - Dispatcher.trigger('newPageReady', - this.History.currentStatus(), - {}, - container, - this.Dom.currentHTML - ); - Dispatcher.trigger('transitionCompleted', this.History.currentStatus()); - - this.bindEvents(); - }, - - /** - * Attach the eventlisteners - * - * @memberOf Barba.Pjax - * @private - */ - bindEvents: function() { - document.addEventListener('click', - this.onLinkClick.bind(this) - ); - - window.addEventListener('popstate', - this.onStateChange.bind(this) - ); - }, - - /** - * Return the currentURL cleaned - * - * @memberOf Barba.Pjax - * @return {String} currentUrl - */ - getCurrentUrl: function() { - return Utils.cleanLink( - Utils.getCurrentUrl() - ); - }, - - /** - * Change the URL with pushstate and trigger the state change - * - * @memberOf Barba.Pjax - * @param {String} newUrl - */ - goTo: function(url) { - window.history.pushState(null, null, url); - this.onStateChange(); - }, - - /** - * Force the browser to go to a certain url - * - * @memberOf Barba.Pjax - * @param {String} url - * @private - */ - forceGoTo: function(url) { - window.location = url; - }, - - /** - * Load an url, will start an xhr request or load from the cache - * - * @memberOf Barba.Pjax - * @private - * @param {String} url - * @return {Promise} - */ - load: function(url) { - var deferred = Utils.deferred(); - var _this = this; - var xhr; - - xhr = this.Cache.get(url); - - if (!xhr) { - xhr = Utils.xhr(url); - this.Cache.set(url, xhr); - } - - xhr.then( - function(data) { - var container = _this.Dom.parseResponse(data); - - _this.Dom.putContainer(container); - - if (!_this.cacheEnabled) - _this.Cache.reset(); - - deferred.resolve(container); - }, - function() { - //Something went wrong (timeout, 404, 505...) - _this.forceGoTo(url); - - deferred.reject(); - } - ); - - return deferred.promise; - }, - - /** - * Get the .href parameter out of an element - * and handle special cases (like xlink:href) - * - * @private - * @memberOf Barba.Pjax - * @param {HTMLElement} el - * @return {String} href - */ - getHref: function(el) { - if (!el) { - return undefined; - } - - if (el.getAttribute && typeof el.getAttribute('xlink:href') === 'string') { - return el.getAttribute('xlink:href'); - } - - if (typeof el.href === 'string') { - return el.href; - } - - return undefined; - }, - - /** - * Callback called from click event - * - * @memberOf Barba.Pjax - * @private - * @param {MouseEvent} evt - */ - onLinkClick: function(evt) { - var el = evt.target; - - //Go up in the nodelist until we - //find something with an href - while (el && !this.getHref(el)) { - el = el.parentNode; - } - - if (this.preventCheck(evt, el)) { - evt.stopPropagation(); - evt.preventDefault(); - - Dispatcher.trigger('linkClicked', el, evt); - - var href = this.getHref(el); - this.goTo(href); - } - }, - - /** - * Determine if the link should be followed - * - * @memberOf Barba.Pjax - * @param {MouseEvent} evt - * @param {HTMLElement} element - * @return {Boolean} - */ - preventCheck: function(evt, element) { - if (!window.history.pushState) - return false; - - var href = this.getHref(element); - - //User - if (!element || !href) - return false; - - //Middle click, cmd click, and ctrl click - if (evt.which > 1 || evt.metaKey || evt.ctrlKey || evt.shiftKey || evt.altKey) - return false; - - //Ignore target with _blank target - if (element.target && element.target === '_blank') - return false; - - //Check if it's the same domain - if (window.location.protocol !== element.protocol || window.location.hostname !== element.hostname) - return false; - - //Check if the port is the same - if (Utils.getPort() !== Utils.getPort(element.port)) - return false; - - //Ignore case when a hash is being tacked on the current URL - if (href.indexOf('#') > -1) - return false; - - //Ignore case where there is download attribute - if (element.getAttribute && typeof element.getAttribute('download') === 'string') - return false; - - //In case you're trying to load the same page - if (Utils.cleanLink(href) == Utils.cleanLink(location.href)) - return false; - - if (element.classList.contains(this.ignoreClassLink)) - return false; - - return true; - }, - - /** - * Return a transition object - * - * @memberOf Barba.Pjax - * @return {Barba.Transition} Transition object - */ - getTransition: function() { - //User customizable - return HideShowTransition; - }, - - /** - * Method called after a 'popstate' or from .goTo() - * - * @memberOf Barba.Pjax - * @private - */ - onStateChange: function() { - var newUrl = this.getCurrentUrl(); - - if (this.transitionProgress) - this.forceGoTo(newUrl); - - if (this.History.currentStatus().url === newUrl) - return false; - - this.History.add(newUrl); - - var newContainer = this.load(newUrl); - var transition = Object.create(this.getTransition()); - - this.transitionProgress = true; - - Dispatcher.trigger('initStateChange', - this.History.currentStatus(), - this.History.prevStatus() - ); - - var transitionInstance = transition.init( - this.Dom.getContainer(), - newContainer - ); - - newContainer.then( - this.onNewContainerLoaded.bind(this) - ); - - transitionInstance.then( - this.onTransitionEnd.bind(this) - ); - }, - - /** - * Function called as soon the new container is ready - * - * @memberOf Barba.Pjax - * @private - * @param {HTMLElement} container - */ - onNewContainerLoaded: function(container) { - var currentStatus = this.History.currentStatus(); - currentStatus.namespace = this.Dom.getNamespace(container); - - Dispatcher.trigger('newPageReady', - this.History.currentStatus(), - this.History.prevStatus(), - container, - this.Dom.currentHTML - ); - }, - - /** - * Function called as soon the transition is finished - * - * @memberOf Barba.Pjax - * @private - */ - onTransitionEnd: function() { - this.transitionProgress = false; - - Dispatcher.trigger('transitionCompleted', - this.History.currentStatus(), - this.History.prevStatus() - ); - } - }; - - module.exports = Pjax; - - -/***/ }, -/* 11 */ -/***/ function(module, exports, __webpack_require__) { - - var BaseTransition = __webpack_require__(4); - - /** - * Basic Transition object, wait for the new Container to be ready, - * scroll top, and finish the transition (removing the old container and displaying the new one) - * - * @private - * @namespace Barba.HideShowTransition - * @augments Barba.BaseTransition - */ - var HideShowTransition = BaseTransition.extend({ - start: function() { - this.newContainerLoading.then(this.finish.bind(this)); - }, - - finish: function() { - document.body.scrollTop = 0; - this.done(); - } - }); - - module.exports = HideShowTransition; - - -/***/ }, -/* 12 */ -/***/ function(module, exports) { - - /** - * Object that is going to deal with DOM parsing/manipulation - * - * @namespace Barba.Pjax.Dom - * @type {Object} - */ - var Dom = { - /** - * The name of the data attribute on the container - * - * @memberOf Barba.Pjax.Dom - * @type {String} - * @default - */ - dataNamespace: 'namespace', - - /** - * Id of the main wrapper - * - * @memberOf Barba.Pjax.Dom - * @type {String} - * @default - */ - wrapperId: 'barba-wrapper', - - /** - * Class name used to identify the containers - * - * @memberOf Barba.Pjax.Dom - * @type {String} - * @default - */ - containerClass: 'barba-container', - - /** - * Full HTML String of the current page. - * By default is the innerHTML of the initial loaded page. - * - * Each time a new page is loaded, the value is the response of the xhr call. - * - * @memberOf Barba.Pjax.Dom - * @type {String} - */ - currentHTML: document.documentElement.innerHTML, - - /** - * Parse the responseText obtained from the xhr call - * - * @memberOf Barba.Pjax.Dom - * @private - * @param {String} responseText - * @return {HTMLElement} - */ - parseResponse: function(responseText) { - this.currentHTML = responseText; - - var wrapper = document.createElement('div'); - wrapper.innerHTML = responseText; - - var titleEl = wrapper.querySelector('title'); - - if (titleEl) - document.title = titleEl.textContent; - - return this.getContainer(wrapper); - }, - - /** - * Get the main barba wrapper by the ID `wrapperId` - * - * @memberOf Barba.Pjax.Dom - * @return {HTMLElement} element - */ - getWrapper: function() { - var wrapper = document.getElementById(this.wrapperId); - - if (!wrapper) - throw new Error('Barba.js: wrapper not found!'); - - return wrapper; - }, - - /** - * Get the container on the current DOM, - * or from an HTMLElement passed via argument - * - * @memberOf Barba.Pjax.Dom - * @private - * @param {HTMLElement} element - * @return {HTMLElement} - */ - getContainer: function(element) { - if (!element) - element = document.body; - - if (!element) - throw new Error('Barba.js: DOM not ready!'); - - var container = this.parseContainer(element); - - if (container && container.jquery) - container = container[0]; - - if (!container) - throw new Error('Barba.js: no container found'); - - return container; - }, - - /** - * Get the namespace of the container - * - * @memberOf Barba.Pjax.Dom - * @private - * @param {HTMLElement} element - * @return {String} - */ - getNamespace: function(element) { - if (element && element.dataset) { - return element.dataset[this.dataNamespace]; - } else if (element) { - return element.getAttribute('data-' + this.dataNamespace); - } - - return null; - }, - - /** - * Put the container on the page - * - * @memberOf Barba.Pjax.Dom - * @private - * @param {HTMLElement} element - */ - putContainer: function(element) { - element.style.visibility = 'hidden'; - - var wrapper = this.getWrapper(); - wrapper.appendChild(element); - }, - - /** - * Get container selector - * - * @memberOf Barba.Pjax.Dom - * @private - * @param {HTMLElement} element - * @return {HTMLElement} element - */ - parseContainer: function(element) { - return element.querySelector('.' + this.containerClass); - } - }; - - module.exports = Dom; - - -/***/ }, -/* 13 */ -/***/ function(module, exports, __webpack_require__) { - - var Utils = __webpack_require__(5); - var Pjax = __webpack_require__(10); - - /** - * Prefetch - * - * @namespace Barba.Prefetch - * @type {Object} - */ - var Prefetch = { - /** - * Class name used to ignore prefetch on links - * - * @memberOf Barba.Prefetch - * @type {String} - * @default - */ - ignoreClassLink: 'no-barba-prefetch', - - /** - * Init the event listener on mouseover and touchstart - * for the prefetch - * - * @memberOf Barba.Prefetch - */ - init: function() { - if (!window.history.pushState) { - return false; - } - - document.body.addEventListener('mouseover', this.onLinkEnter.bind(this)); - document.body.addEventListener('touchstart', this.onLinkEnter.bind(this)); - }, - - /** - * Callback for the mousehover/touchstart - * - * @memberOf Barba.Prefetch - * @private - * @param {Object} evt - */ - onLinkEnter: function(evt) { - var el = evt.target; - - while (el && !Pjax.getHref(el)) { - el = el.parentNode; - } - - if (!el || el.classList.contains(this.ignoreClassLink)) { - return; - } - - var url = Pjax.getHref(el); - - //Check if the link is elegible for Pjax - if (Pjax.preventCheck(evt, el) && !Pjax.Cache.get(url)) { - var xhr = Utils.xhr(url); - Pjax.Cache.set(url, xhr); - } - } - }; - - module.exports = Prefetch; - - -/***/ } -/******/ ]) +},{}]},{},[1]) +(1) }); -; -//# sourceMappingURL=barba.js.map !function(root, factory) { "function" == typeof define && define.amd ? // AMD. Register as an anonymous module unless amdModuleId is set define([], function() { @@ -1718,7 +792,7 @@ return /******/ (function(modules) { // webpackBootstrap // like Node. module.exports = factory() : root.svg4everybody = factory(); }(this, function() { - /*! svg4everybody v2.1.6 | github.com/jonathantneal/svg4everybody */ + /*! svg4everybody v2.1.9 | github.com/jonathantneal/svg4everybody */ function embed(parent, svg, target) { // if the target exists if (target) { @@ -1763,9 +837,9 @@ return /******/ (function(modules) { // webpackBootstrap for (// get the cached index var index = 0; index < uses.length; ) { // get the current - var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent); - if (svg) { - var src = use.getAttribute("xlink:href") || use.getAttribute("href"); + var use = uses[index], parent = use.parentNode, svg = getSVGAncestor(parent), src = use.getAttribute("xlink:href") || use.getAttribute("href"); + if (!src && opts.attributeName && (src = use.getAttribute(opts.attributeName)), + svg && src) { if (polyfill) { if (!opts.validate || opts.validate(src, svg, use)) { // remove the element @@ -1787,7 +861,7 @@ return /******/ (function(modules) { // webpackBootstrap loadreadystatechange(xhr); } else { // embed the local id into the svg - embed(parent, document.getElementById(id)); + embed(parent, svg, document.getElementById(id)); } } else { // increase the index when the previous value was not "valid" diff --git a/www/assets/styles/main.css b/www/assets/styles/main.css index 5b9e60d..1629300 100644 --- a/www/assets/styles/main.css +++ b/www/assets/styles/main.css @@ -1,884 +1 @@ -/* - * ! Locomotive Boilerplate - 2017-12-07 - */ -/*! normalize.css v5.0.0 | MIT License | github.com/necolas/normalize.css */ -/** - * 1. Change the default font family in all browsers (opinionated). - * 2. Correct the line height in all browsers. - * 3. Prevent adjustments of font size after orientation changes in - * IE on Windows Phone and in iOS. - */ -/* Document - ========================================================================== */ -html { - font-family: sans-serif; - /* 1 */ - line-height: 1.15; - /* 2 */ - -ms-text-size-adjust: 100%; - /* 3 */ - -webkit-text-size-adjust: 100%; - /* 3 */ -} - -/* Sections - ========================================================================== */ -/** - * Remove the margin in all browsers (opinionated). - */ -body { - margin: 0; -} - -/** - * Add the correct display in IE 9-. - */ -article, -aside, -footer, -header, -nav, -section { - display: block; -} - -/** - * Correct the font size and margin on `h1` elements within `section` and - * `article` contexts in Chrome, Firefox, and Safari. - */ -h1 { - margin: 0.67em 0; - font-size: 2em; -} - -/* Grouping content - ========================================================================== */ -/** - * Add the correct display in IE 9-. - * 1. Add the correct display in IE. - */ -figcaption, -figure, -main { - /* 1 */ - display: block; -} - -/** - * Add the correct margin in IE 8. - */ -figure { - margin: 1em 40px; -} - -/** - * 1. Add the correct box sizing in Firefox. - * 2. Show the overflow in Edge and IE. - */ -hr { - overflow: visible; - /* 2 */ - box-sizing: content-box; - /* 1 */ - height: 0; - /* 1 */ -} - -/** - * 1. Correct the inheritance and scaling of font size in all browsers. - * 2. Correct the odd `em` font sizing in all browsers. - */ -pre { - font-size: 1em; - /* 2 */ - font-family: monospace, monospace; - /* 1 */ -} - -/* Text-level semantics - ========================================================================== */ -/** - * 1. Remove the gray background on active links in IE 10. - * 2. Remove gaps in links underline in iOS 8+ and Safari 8+. - */ -a { - background-color: transparent; - /* 1 */ - -webkit-text-decoration-skip: objects; - /* 2 */ -} - -/** - * Remove the outline on focused links when they are also active or hovered - * in all browsers (opinionated). - */ -a:active, -a:hover { - outline-width: 0; -} - -/** - * 1. Remove the bottom border in Firefox 39-. - * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari. - */ -abbr[title] { - border-bottom: none; - /* 1 */ - text-decoration: underline; - /* 2 */ - text-decoration: underline dotted; - /* 2 */ -} - -/** - * Prevent the duplicate application of `bolder` by the next rule in Safari 6. - */ -b, -strong { - font-weight: inherit; -} - -/** - * Add the correct font weight in Chrome, Edge, and Safari. - */ -b, -strong { - font-weight: bolder; -} - -/** - * 1. Correct the inheritance and scaling of font size in all browsers. - * 2. Correct the odd `em` font sizing in all browsers. - */ -code, -kbd, -samp { - font-size: 1em; - /* 2 */ - font-family: monospace, monospace; - /* 1 */ -} - -/** - * Add the correct font style in Android 4.3-. - */ -dfn { - font-style: italic; -} - -/** - * Add the correct background and color in IE 9-. - */ -mark { - background-color: #FFFF00; - color: #000000; -} - -/** - * Add the correct font size in all browsers. - */ -small { - font-size: 80%; -} - -/** - * Prevent `sub` and `sup` elements from affecting the line height in - * all browsers. - */ -sub, -sup { - position: relative; - vertical-align: baseline; - font-size: 75%; - line-height: 0; -} - -sub { - bottom: -0.25em; -} - -sup { - top: -0.5em; -} - -/* Embedded content - ========================================================================== */ -/** - * Add the correct display in IE 9-. - */ -audio, -video { - display: inline-block; -} - -/** - * Add the correct display in iOS 4-7. - */ -audio:not([controls]) { - display: none; - height: 0; -} - -/** - * Remove the border on images inside links in IE 10-. - */ -img { - border-style: none; -} - -/** - * Hide the overflow in IE. - */ -svg:not(:root) { - overflow: hidden; -} - -/* Forms - ========================================================================== */ -/** - * 1. Change the font styles in all browsers (opinionated). - * 2. Remove the margin in Firefox and Safari. - */ -button, -input, -optgroup, -select, -textarea { - margin: 0; - /* 2 */ - font-size: 100%; - /* 1 */ - font-family: sans-serif; - /* 1 */ - line-height: 1.15; - /* 1 */ -} - -/** - * Show the overflow in IE. - * 1. Show the overflow in Edge. - */ -button, -input { - /* 1 */ - overflow: visible; -} - -/** - * Remove the inheritance of text transform in Edge, Firefox, and IE. - * 1. Remove the inheritance of text transform in Firefox. - */ -button, -select { - /* 1 */ - text-transform: none; -} - -/** - * 1. Prevent a WebKit bug where (2) destroys native `audio` and `video` - * controls in Android 4. - * 2. Correct the inability to style clickable types in iOS and Safari. - * 3. Remove the border-radius in Chrome 62+ on macOS. - */ -button, -html [type="button"], -[type="reset"], -[type="submit"] { - -webkit-appearance: button; - /* 2 */ - border-radius: 0; - /* 3 */ -} - -/** - * Remove the inner border and padding in Firefox. - */ -button::-moz-focus-inner, -[type="button"]::-moz-focus-inner, -[type="reset"]::-moz-focus-inner, -[type="submit"]::-moz-focus-inner { - padding: 0; - border-style: none; -} - -/** - * Restore the focus styles unset by the previous rule. - */ -button:-moz-focusring, -[type="button"]:-moz-focusring, -[type="reset"]:-moz-focusring, -[type="submit"]:-moz-focusring { - outline: 1px dotted ButtonText; -} - -/** - * Change the border, margin, and padding in all browsers (opinionated). - */ -fieldset { - margin: 0 2px; - padding: 0.35em 0.625em 0.75em; - border: 1px solid #C0C0C0; -} - -/** - * 1. Correct the text wrapping in Edge and IE. - * 2. Correct the color inheritance from `fieldset` elements in IE. - * 3. Remove the padding so developers are not caught out when they zero out - * `fieldset` elements in all browsers. - */ -legend { - display: table; - /* 1 */ - box-sizing: border-box; - /* 1 */ - padding: 0; - /* 3 */ - max-width: 100%; - /* 1 */ - color: inherit; - /* 2 */ - white-space: normal; - /* 1 */ -} - -/** - * 1. Add the correct display in IE 9-. - * 2. Add the correct vertical alignment in Chrome, Firefox, and Opera. - */ -progress { - display: inline-block; - /* 1 */ - vertical-align: baseline; - /* 2 */ -} - -/** - * Remove the default vertical scrollbar in IE. - */ -textarea { - overflow: auto; -} - -/** - * 1. Add the correct box sizing in IE 10-. - * 2. Remove the padding in IE 10-. - */ -[type="checkbox"], -[type="radio"] { - box-sizing: border-box; - /* 1 */ - padding: 0; - /* 2 */ -} - -/** - * Correct the cursor style of increment and decrement buttons in Chrome. - */ -[type="number"]::-webkit-inner-spin-button, -[type="number"]::-webkit-outer-spin-button { - height: auto; -} - -/** - * 1. Correct the odd appearance in Chrome and Safari. - * 2. Correct the outline style in Safari. - */ -[type="search"] { - outline-offset: -2px; - /* 2 */ - -webkit-appearance: textfield; - /* 1 */ -} - -/** - * Remove the inner padding and cancel buttons in Chrome and Safari on macOS. - */ -[type="search"]::-webkit-search-cancel-button, -[type="search"]::-webkit-search-decoration { - -webkit-appearance: none; -} - -/** - * 1. Correct the inability to style clickable types in iOS and Safari. - * 2. Change font properties to `inherit` in Safari. - */ -::-webkit-file-upload-button { - font: inherit; - /* 2 */ - -webkit-appearance: button; - /* 1 */ -} - -/* Interactive - ========================================================================== */ -/* - * Add the correct display in IE 9-. - * 1. Add the correct display in Edge, IE, and Firefox. - */ -details, -menu { - display: block; -} - -/* - * Add the correct display in all browsers. - */ -summary { - display: list-item; -} - -/* Scripting - ========================================================================== */ -/** - * Add the correct display in IE 9-. - */ -canvas { - display: inline-block; -} - -/** - * Add the correct display in IE. - */ -template { - display: none; -} - -/* Hidden - ========================================================================== */ -/** - * Add the correct display in IE 10-. - */ -[hidden] { - display: none; -} - -html { - box-sizing: border-box; -} - -template, -[hidden] { - display: none; -} - -*, -:before, -:after { - box-sizing: inherit; -} - -address { - font-style: inherit; -} - -dfn, -cite, -em, -i { - font-style: italic; -} - -b, -strong { - font-weight: 700; -} - -a { - text-decoration: none; -} - -a svg { - pointer-events: none; -} - -/** - * 1. Single taps should be dispatched immediately on clickable elements - */ -a, area, button, input, label, select, textarea, [tabindex] { - -ms-touch-action: manipulation; - /* [1] */ - touch-action: manipulation; -} - -[hreflang] > abbr[title] { - text-decoration: none; -} - -table { - border-spacing: 0; - border-collapse: collapse; -} - -hr { - display: block; - margin: 1em 0; - padding: 0; - height: 1px; - border: 0; - border-top: 1px solid #CCCCCC; -} - -audio, -canvas, -iframe, -img, -svg, -video { - vertical-align: middle; - /* [1] */ -} - -audio:not([controls]) { - display: none; - height: 0; -} - -img, -svg { - max-width: 100%; - /* [2] */ - height: auto; -} - -img[width], img[height], -svg[width], -svg[height] { - /* [4] */ - max-width: none; -} - -img { - font-style: italic; - /* [4] */ -} - -svg { - fill: currentColor; - /* [5] */ -} - -input, -select, -textarea { - display: block; - margin: 0; - padding: 0; - width: 100%; - outline: 0; - border: 0; - border-radius: 0; - background: none transparent; - color: inherit; - font: inherit; - line-height: normal; - -webkit-appearance: none; - -moz-appearance: none; - appearance: none; -} - -select { - text-transform: none; -} - -select::-ms-expand { - display: none; -} - -select::-ms-value { - background: none; - color: inherit; -} - -textarea { - overflow: auto; - resize: vertical; -} - -button, -.o-button { - display: inline-block; - /* [1] */ - overflow: visible; - /* [2] */ - margin: 0; - /* [3] */ - padding: 0; - outline: 0; - border: 0; - background: none transparent; - color: inherit; - vertical-align: middle; - /* [4] */ - text-align: center; - /* [3] */ - text-decoration: none; - text-transform: none; - font: inherit; - /* [5] */ - line-height: normal; - cursor: pointer; - /* [6] */ - -webkit-user-select: none; - -moz-user-select: none; - -ms-user-select: none; - user-select: none; -} - -button:focus, button:hover, -.o-button:focus, -.o-button:hover { - text-decoration: none; -} - -html { - overflow-y: scroll; - /* [2] */ - min-height: 100%; - /* [3] */ - color: #222222; - font-size: 1em; - /* [1] */ - font-family: sans-serif; - line-height: 1.5; - /* [1] */ -} - -::-moz-selection { - background-color: #FFFFFF; - color: #3297FD; - text-shadow: none; -} - -::selection { - background-color: #FFFFFF; - color: #3297FD; - text-shadow: none; -} - -a { - color: #1A0DAB; -} - -a:focus, a:hover { - color: #13097c; -} - -.o-h, h1, .o-h1, h2, .o-h2, h3, .o-h3, h4, .o-h4, h5, .o-h5, h6, .o-h6 { - margin-top: 0; - line-height: 1.5; -} - -h1, .o-h1 { - font-size: 2.25rem; -} - -h2, .o-h2 { - font-size: 1.75rem; -} - -h3, .o-h3 { - font-size: 1.5rem; -} - -h4, .o-h4 { - font-size: 1.25rem; -} - -h5, .o-h5 { - font-size: 1.125rem; -} - -h6, .o-h6 { - font-size: 1rem; -} - -/* stylelint-disable */ -/* stylelint-enable */ -.o-container { - margin-right: auto; - margin-left: auto; - padding-right: 60px; - padding-left: 60px; - max-width: 2000px; -} - -.o-layout { - margin: 0; - padding: 0; - list-style: none; - font-size: 0; - margin-left: 0; -} - -.o-layout.-gutter { - margin-left: -3.75rem; -} - -.o-layout.-gutter-small { - margin-left: -1.875rem; -} - -.o-layout.-center { - text-align: center; -} - -.o-layout.-right { - text-align: right; -} - -.o-layout.-reverse { - direction: rtl; -} - -.o-layout_item { - display: inline-block; - width: 100%; - vertical-align: top; - font-size: 1rem; - padding-left: 0; -} - -.o-layout.-gutter > .o-layout_item { - padding-left: 3.75rem; -} - -.o-layout.-gutter-small > .o-layout_item { - padding-left: 1.875rem; -} - -.o-layout.-middle > .o-layout_item { - vertical-align: middle; -} - -.o-layout.-bottom > .o-layout_item { - vertical-align: bottom; -} - -.o-layout.-center > .o-layout_item, -.o-layout.-right > .o-layout_item, -.o-layout.-reverse > .o-layout_item { - text-align: left; -} - -.o-layout.-reverse > .o-layout_item { - direction: ltr; -} - -.o-label, .o-checkbox-label, .o-radio-label { - display: block; - margin-bottom: 0.9375rem; -} - -.o-input, .o-checkbox-label::before, .o-radio-label::before, .o-checkbox-label::after, .o-radio-label::after, .o-select, .o-textarea { - padding: 0.625rem; - border-width: 1px; - border-style: solid; - border-color: lightgray; - background-color: white; -} - -.o-input:focus, .o-checkbox-label:focus::before, .o-radio-label:focus::before, .o-checkbox-label:focus::after, .o-radio-label:focus::after, .o-select:focus, .o-textarea:focus { - border-color: gray; -} - -.o-input::-webkit-input-placeholder, .o-select::-webkit-input-placeholder, .o-textarea::-webkit-input-placeholder { - color: gray; -} - -.o-input:-ms-input-placeholder, .o-select:-ms-input-placeholder, .o-textarea:-ms-input-placeholder { - color: gray; -} - -.o-input::placeholder, .o-select::placeholder, .o-textarea::placeholder { - color: gray; -} - -.o-checkbox, .o-radio { - position: absolute; - width: 0; - opacity: 0; -} - -.o-checkbox:focus + .o-checkbox-label::before, .o-radio:focus + .o-checkbox-label::before, .o-checkbox:focus + .o-radio-label::before, .o-radio:focus + .o-radio-label::before { - border-color: gray; -} - -.o-checkbox:checked + .o-checkbox-label::after, .o-radio:checked + .o-checkbox-label::after, .o-checkbox:checked + .o-radio-label::after, .o-radio:checked + .o-radio-label::after { - opacity: 1; -} - -.o-checkbox-label, .o-radio-label { - position: relative; - display: inline-block; - margin-right: 0.5em; - padding-left: 1.75rem; -} - -.o-checkbox-label::before, .o-radio-label::before, .o-checkbox-label::after, .o-radio-label::after { - position: absolute; - top: 50%; - left: 0; - display: inline-block; - margin-top: -0.5625rem; - padding: 0; - width: 1.125rem; - height: 1.125rem; - content: ""; -} - -.o-checkbox-label::after, .o-radio-label::after { - border-color: transparent; - background-color: transparent; - background-image: url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20version%3D%221.1%22%20x%3D%220%22%20y%3D%220%22%20width%3D%2213%22%20height%3D%2210.5%22%20viewBox%3D%220%200%2013%2010.5%22%20enable-background%3D%22new%200%200%2013%2010.5%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23424242%22%20d%3D%22M4.8%205.8L2.4%203.3%200%205.7l4.8%204.8L13%202.4c0%200-2.4-2.4-2.4-2.4L4.8%205.8z%22%2F%3E%3C%2Fsvg%3E"); - background-position: center; - background-size: 0.8125rem; - background-repeat: no-repeat; - opacity: 0; -} - -.o-radio-label::before, .o-radio-label::after { - border-radius: 50%; -} - -.o-radio-label::after { - background-image: url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20version%3D%221.1%22%20x%3D%220%22%20y%3D%220%22%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20enable-background%3D%22new%200%200%2013%2013%22%20xml%3Aspace%3D%22preserve%22%3E%3Ccircle%20fill%3D%22%23424242%22%20cx%3D%226.5%22%20cy%3D%226.5%22%20r%3D%226.5%22%2F%3E%3C%2Fsvg%3E"); - background-size: 0.5rem; -} - -.o-select { - position: relative; - z-index: 1; - padding-right: 2.5rem; -} - -.o-select-wrap { - position: relative; -} - -.o-select-wrap::after { - position: absolute; - top: 0; - right: 0; - bottom: 0; - z-index: 2; - width: 2.5rem; - background-image: url("data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20version%3D%221.1%22%20x%3D%220%22%20y%3D%220%22%20width%3D%2213%22%20height%3D%2211.3%22%20viewBox%3D%220%200%2013%2011.3%22%20enable-background%3D%22new%200%200%2013%2011.3%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23424242%22%20points%3D%226.5%2011.3%203.3%205.6%200%200%206.5%200%2013%200%209.8%205.6%20%22%2F%3E%3C%2Fsvg%3E"); - background-position: center; - background-size: 0.625rem; - background-repeat: no-repeat; - content: ""; - pointer-events: none; -} - -.o-textarea { - min-height: 6.25rem; -} - -.o-button { - padding: 0.625rem; - background-color: lightgray; -} - -.o-button:focus, .o-button:hover { - background-color: gray; -} +/*! normalize.css v5.0.0 | MIT License | github.com/necolas/normalize.css */html{font-family:sans-serif;line-height:1.15;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,footer,header,nav,section{display:block}h1{margin:.67em 0;font-size:2em}figcaption,figure,main{display:block}figure{margin:1em 40px}hr{overflow:visible;-webkit-box-sizing:content-box;box-sizing:content-box;height:0}pre{font-size:1em;font-family:monospace,monospace}a{background-color:transparent;-webkit-text-decoration-skip:objects}a:active,a:hover{outline-width:0}abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}b,strong{font-weight:inherit}b,strong{font-weight:bolder}code,kbd,samp{font-size:1em;font-family:monospace,monospace}dfn{font-style:italic}mark{background-color:#ff0;color:#000}small{font-size:80%}sub,sup{position:relative;vertical-align:baseline;font-size:75%;line-height:0}sub{bottom:-.25em}sup{top:-.5em}audio,video{display:inline-block}audio:not([controls]){display:none;height:0}img{border-style:none}svg:not(:root){overflow:hidden}button,input,optgroup,select,textarea{margin:0;font-size:100%;font-family:sans-serif;line-height:1.15}button,input{overflow:visible}button,select{text-transform:none}[type=reset],[type=submit],button,html [type=button]{-webkit-appearance:button;border-radius:0}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{padding:0;border-style:none}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{margin:0 2px;padding:.35em .625em .75em;border:1px solid silver}legend{display:table;-webkit-box-sizing:border-box;box-sizing:border-box;padding:0;max-width:100%;color:inherit;white-space:normal}progress{display:inline-block;vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{-webkit-box-sizing:border-box;box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:textfield}[type=search]::-webkit-search-cancel-button,[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}details,menu{display:block}summary{display:list-item}canvas{display:inline-block}template{display:none}[hidden]{display:none}html{-webkit-box-sizing:border-box;box-sizing:border-box}[hidden],template{display:none}*,:after,:before{-webkit-box-sizing:inherit;box-sizing:inherit}address{font-style:inherit}cite,dfn,em,i{font-style:italic}b,strong{font-weight:700}a{text-decoration:none}a svg{pointer-events:none}[tabindex],a,area,button,input,label,select,textarea{-ms-touch-action:manipulation;touch-action:manipulation}[hreflang]>abbr[title]{text-decoration:none}table{border-spacing:0;border-collapse:collapse}hr{display:block;margin:1em 0;padding:0;height:1px;border:0;border-top:1px solid #ccc}audio,canvas,iframe,img,svg,video{vertical-align:middle}audio:not([controls]){display:none;height:0}img,svg{max-width:100%;height:auto}img[height],img[width],svg[height],svg[width]{max-width:none}img{font-style:italic}svg{fill:currentColor}input,select,textarea{display:block;margin:0;padding:0;width:100%;outline:0;border:0;border-radius:0;background:none transparent;color:inherit;font:inherit;line-height:normal;-webkit-appearance:none;-moz-appearance:none;appearance:none}select{text-transform:none}select::-ms-expand{display:none}select::-ms-value{background:0 0;color:inherit}textarea{overflow:auto;resize:vertical}.o-button,button{display:inline-block;overflow:visible;margin:0;padding:0;outline:0;border:0;background:none transparent;color:inherit;vertical-align:middle;text-align:center;text-decoration:none;text-transform:none;font:inherit;line-height:normal;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.o-button:focus,.o-button:hover,button:focus,button:hover{text-decoration:none}html{overflow-y:scroll;min-height:100%;color:#222;font-size:1em;font-family:sans-serif;line-height:1.5}::-moz-selection{background-color:#fff;color:#3297fd;text-shadow:none}::selection{background-color:#fff;color:#3297fd;text-shadow:none}a{color:#1a0dab}a:focus,a:hover{color:#13097c}.o-h,.o-h1,.o-h2,.o-h3,.o-h4,.o-h5,.o-h6,h1,h2,h3,h4,h5,h6{margin-top:0;line-height:1.5}.o-h1,h1{font-size:2.25rem}.o-h2,h2{font-size:1.75rem}.o-h3,h3{font-size:1.5rem}.o-h4,h4{font-size:1.25rem}.o-h5,h5{font-size:1.125rem}.o-h6,h6{font-size:1rem}.o-container{margin-right:auto;margin-left:auto;padding-right:60px;padding-left:60px;max-width:2000px}.o-layout{margin:0;padding:0;list-style:none;font-size:0;margin-left:0}.o-layout.-gutter{margin-left:-3.75rem}.o-layout.-gutter-small{margin-left:-1.875rem}.o-layout.-center{text-align:center}.o-layout.-right{text-align:right}.o-layout.-reverse{direction:rtl}.o-layout_item{display:inline-block;width:100%;vertical-align:top;font-size:1rem;padding-left:0}.o-layout.-gutter>.o-layout_item{padding-left:3.75rem}.o-layout.-gutter-small>.o-layout_item{padding-left:1.875rem}.o-layout.-middle>.o-layout_item{vertical-align:middle}.o-layout.-bottom>.o-layout_item{vertical-align:bottom}.o-layout.-center>.o-layout_item,.o-layout.-reverse>.o-layout_item,.o-layout.-right>.o-layout_item{text-align:left}.o-layout.-reverse>.o-layout_item{direction:ltr}.o-checkbox-label,.o-label,.o-radio-label{display:block;margin-bottom:.9375rem}.o-checkbox-label::after,.o-checkbox-label::before,.o-input,.o-radio-label::after,.o-radio-label::before,.o-select,.o-textarea{padding:.625rem;border-width:1px;border-style:solid;border-color:#d3d3d3;background-color:#fff}.o-checkbox-label:focus::after,.o-checkbox-label:focus::before,.o-input:focus,.o-radio-label:focus::after,.o-radio-label:focus::before,.o-select:focus,.o-textarea:focus{border-color:gray}.o-input::-webkit-input-placeholder,.o-select::-webkit-input-placeholder,.o-textarea::-webkit-input-placeholder{color:gray}.o-input:-ms-input-placeholder,.o-select:-ms-input-placeholder,.o-textarea:-ms-input-placeholder{color:gray}.o-input::-ms-input-placeholder,.o-select::-ms-input-placeholder,.o-textarea::-ms-input-placeholder{color:gray}.o-input::placeholder,.o-select::placeholder,.o-textarea::placeholder{color:gray}.o-checkbox,.o-radio{position:absolute;width:0;opacity:0}.o-checkbox:focus+.o-checkbox-label::before,.o-checkbox:focus+.o-radio-label::before,.o-radio:focus+.o-checkbox-label::before,.o-radio:focus+.o-radio-label::before{border-color:gray}.o-checkbox:checked+.o-checkbox-label::after,.o-checkbox:checked+.o-radio-label::after,.o-radio:checked+.o-checkbox-label::after,.o-radio:checked+.o-radio-label::after{opacity:1}.o-checkbox-label,.o-radio-label{position:relative;display:inline-block;margin-right:.5em;padding-left:1.75rem}.o-checkbox-label::after,.o-checkbox-label::before,.o-radio-label::after,.o-radio-label::before{position:absolute;top:50%;left:0;display:inline-block;margin-top:-.5625rem;padding:0;width:1.125rem;height:1.125rem;content:""}.o-checkbox-label::after,.o-radio-label::after{border-color:transparent;background-color:transparent;background-image:url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20version%3D%221.1%22%20x%3D%220%22%20y%3D%220%22%20width%3D%2213%22%20height%3D%2210.5%22%20viewBox%3D%220%200%2013%2010.5%22%20enable-background%3D%22new%200%200%2013%2010.5%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpath%20fill%3D%22%23424242%22%20d%3D%22M4.8%205.8L2.4%203.3%200%205.7l4.8%204.8L13%202.4c0%200-2.4-2.4-2.4-2.4L4.8%205.8z%22%2F%3E%3C%2Fsvg%3E);background-position:center;background-size:.8125rem;background-repeat:no-repeat;opacity:0}.o-radio-label::after,.o-radio-label::before{border-radius:50%}.o-radio-label::after{background-image:url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20version%3D%221.1%22%20x%3D%220%22%20y%3D%220%22%20width%3D%2213%22%20height%3D%2213%22%20viewBox%3D%220%200%2013%2013%22%20enable-background%3D%22new%200%200%2013%2013%22%20xml%3Aspace%3D%22preserve%22%3E%3Ccircle%20fill%3D%22%23424242%22%20cx%3D%226.5%22%20cy%3D%226.5%22%20r%3D%226.5%22%2F%3E%3C%2Fsvg%3E);background-size:.5rem}.o-select{position:relative;z-index:1;padding-right:2.5rem}.o-select-wrap{position:relative}.o-select-wrap::after{position:absolute;top:0;right:0;bottom:0;z-index:2;width:2.5rem;background-image:url(data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20version%3D%221.1%22%20x%3D%220%22%20y%3D%220%22%20width%3D%2213%22%20height%3D%2211.3%22%20viewBox%3D%220%200%2013%2011.3%22%20enable-background%3D%22new%200%200%2013%2011.3%22%20xml%3Aspace%3D%22preserve%22%3E%3Cpolygon%20fill%3D%22%23424242%22%20points%3D%226.5%2011.3%203.3%205.6%200%200%206.5%200%2013%200%209.8%205.6%20%22%2F%3E%3C%2Fsvg%3E);background-position:center;background-size:.625rem;background-repeat:no-repeat;content:"";pointer-events:none}.o-textarea{min-height:6.25rem}.o-button{padding:.625rem;background-color:#d3d3d3}.o-button:focus,.o-button:hover{background-color:gray} \ No newline at end of file diff --git a/www/index.html b/www/index.html index bedf3f3..41c49d6 100644 --- a/www/index.html +++ b/www/index.html @@ -1,13 +1,13 @@ - + - Boilerplate + Home | Boilerplate @@ -15,9 +15,24 @@ -
-
-
+ +
+ +
+ +
+
+
Home page with Example module
diff --git a/www/page.html b/www/page.html new file mode 100644 index 0000000..26a0795 --- /dev/null +++ b/www/page.html @@ -0,0 +1,45 @@ + + + + + + + + + + Page | Boilerplate + + + + + + + + +
+ +
+ +
+
+ Lorem ipsum dolor sit amet, consectetur adipisicing elit. Repellendus tempore officia temporibus error rem id, vel perspiciatis eveniet placeat, ducimus fugit vitae sequi, quas deserunt ab eius expedita quia nulla. + +
+
+ + + + + + +