/*!
* vue-router v0.7.5
* (c) 2015 Evan You
* Released under the MIT License.
*/
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["VueRouter"] = factory();
else
root["VueRouter"] = 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 = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _classCallCheck = __webpack_require__(1)['default'];
var _interopRequireDefault = __webpack_require__(2)['default'];
exports.__esModule = true;
var _util = __webpack_require__(3);
var _util2 = _interopRequireDefault(_util);
var _override = __webpack_require__(7);
var _override2 = _interopRequireDefault(_override);
var _routeRecognizer = __webpack_require__(4);
var _routeRecognizer2 = _interopRequireDefault(_routeRecognizer);
var _route = __webpack_require__(8);
var _route2 = _interopRequireDefault(_route);
var _transition = __webpack_require__(18);
var _transition2 = _interopRequireDefault(_transition);
var _directivesView = __webpack_require__(28);
var _directivesView2 = _interopRequireDefault(_directivesView);
var _directivesLink = __webpack_require__(29);
var _directivesLink2 = _interopRequireDefault(_directivesLink);
var _historyAbstract = __webpack_require__(30);
var _historyAbstract2 = _interopRequireDefault(_historyAbstract);
var _historyHash = __webpack_require__(31);
var _historyHash2 = _interopRequireDefault(_historyHash);
var _historyHtml5 = __webpack_require__(32);
var _historyHtml52 = _interopRequireDefault(_historyHtml5);
var historyBackends = {
abstract: _historyAbstract2['default'],
hash: _historyHash2['default'],
html5: _historyHtml52['default']
};
// late bind during install
var Vue = undefined;
/**
* Router constructor
*
* @param {Object} [options]
*/
var Router = (function () {
function Router() {
var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
var _ref$hashbang = _ref.hashbang;
var hashbang = _ref$hashbang === undefined ? true : _ref$hashbang;
var _ref$abstract = _ref.abstract;
var abstract = _ref$abstract === undefined ? false : _ref$abstract;
var _ref$history = _ref.history;
var history = _ref$history === undefined ? false : _ref$history;
var _ref$saveScrollPosition = _ref.saveScrollPosition;
var saveScrollPosition = _ref$saveScrollPosition === undefined ? false : _ref$saveScrollPosition;
var _ref$transitionOnLoad = _ref.transitionOnLoad;
var transitionOnLoad = _ref$transitionOnLoad === undefined ? false : _ref$transitionOnLoad;
var _ref$suppressTransitionError = _ref.suppressTransitionError;
var suppressTransitionError = _ref$suppressTransitionError === undefined ? false : _ref$suppressTransitionError;
var _ref$root = _ref.root;
var root = _ref$root === undefined ? null : _ref$root;
var _ref$linkActiveClass = _ref.linkActiveClass;
var linkActiveClass = _ref$linkActiveClass === undefined ? 'v-link-active' : _ref$linkActiveClass;
_classCallCheck(this, Router);
/* istanbul ignore if */
if (!Router.installed) {
throw new Error('Please install the Router with Vue.use() before ' + 'creating an instance.');
}
// Vue instances
this.app = null;
this._views = [];
this._children = [];
// route recognizer
this._recognizer = new _routeRecognizer2['default']();
this._guardRecognizer = new _routeRecognizer2['default']();
// state
this._started = false;
this._startCb = null;
this._currentRoute = {};
this._currentTransition = null;
this._previousTransition = null;
this._notFoundHandler = null;
this._notFoundRedirect = null;
this._beforeEachHooks = [];
this._afterEachHooks = [];
// feature detection
this._hasPushState = typeof window !== 'undefined' && window.history && window.history.pushState;
// trigger transition on initial render?
this._rendered = false;
this._transitionOnLoad = transitionOnLoad;
// history mode
this._abstract = abstract;
this._hashbang = hashbang;
this._history = this._hasPushState && history;
// other options
this._saveScrollPosition = saveScrollPosition;
this._linkActiveClass = linkActiveClass;
this._suppress = suppressTransitionError;
// create history object
var inBrowser = Vue.util.inBrowser;
this.mode = !inBrowser || this._abstract ? 'abstract' : this._history ? 'html5' : 'hash';
var History = historyBackends[this.mode];
var self = this;
this.history = new History({
root: root,
hashbang: this._hashbang,
onChange: function onChange(path, state, anchor) {
self._match(path, state, anchor);
}
});
}
/**
* Allow directly passing components to a route
* definition.
*
* @param {String} path
* @param {Object} handler
*/
// API ===================================================
/**
* Register a map of top-level paths.
*
* @param {Object} map
*/
Router.prototype.map = function map(_map) {
for (var route in _map) {
this.on(route, _map[route]);
}
};
/**
* Register a single root-level path
*
* @param {String} rootPath
* @param {Object} handler
* - {String} component
* - {Object} [subRoutes]
* - {Boolean} [forceRefresh]
* - {Function} [before]
* - {Function} [after]
*/
Router.prototype.on = function on(rootPath, handler) {
if (rootPath === '*') {
this._notFound(handler);
} else {
this._addRoute(rootPath, handler, []);
}
};
/**
* Set redirects.
*
* @param {Object} map
*/
Router.prototype.redirect = function redirect(map) {
for (var path in map) {
this._addRedirect(path, map[path]);
}
};
/**
* Set aliases.
*
* @param {Object} map
*/
Router.prototype.alias = function alias(map) {
for (var path in map) {
this._addAlias(path, map[path]);
}
};
/**
* Set global before hook.
*
* @param {Function} fn
*/
Router.prototype.beforeEach = function beforeEach(fn) {
this._beforeEachHooks.push(fn);
};
/**
* Set global after hook.
*
* @param {Function} fn
*/
Router.prototype.afterEach = function afterEach(fn) {
this._afterEachHooks.push(fn);
};
/**
* Navigate to a given path.
* The path can be an object describing a named path in
* the format of { name: '...', params: {}, query: {}}
* The path is assumed to be already decoded, and will
* be resolved against root (if provided)
*
* @param {String|Object} path
* @param {Boolean} [replace]
*/
Router.prototype.go = function go(path) {
var replace = false;
var append = false;
if (Vue.util.isObject(path)) {
replace = path.replace;
append = path.append;
}
path = this._stringifyPath(path);
if (path) {
this.history.go(path, replace, append);
}
};
/**
* Short hand for replacing current path
*
* @param {String} path
*/
Router.prototype.replace = function replace(path) {
this.go({ path: path, replace: true });
};
/**
* Start the router.
*
* @param {VueConstructor} App
* @param {String|Element} container
* @param {Function} [cb]
*/
Router.prototype.start = function start(App, container, cb) {
/* istanbul ignore if */
if (this._started) {
_util.warn('already started.');
return;
}
this._started = true;
this._startCb = cb;
if (!this.app) {
/* istanbul ignore if */
if (!App || !container) {
throw new Error('Must start vue-router with a component and a ' + 'root container.');
}
this._appContainer = container;
var Ctor = this._appConstructor = typeof App === 'function' ? App : Vue.extend(App);
// give it a name for better debugging
Ctor.options.name = Ctor.options.name || 'RouterApp';
}
this.history.start();
};
/**
* Stop listening to route changes.
*/
Router.prototype.stop = function stop() {
this.history.stop();
this._started = false;
};
// Internal methods ======================================
/**
* Add a route containing a list of segments to the internal
* route recognizer. Will be called recursively to add all
* possible sub-routes.
*
* @param {String} path
* @param {Object} handler
* @param {Array} segments
*/
Router.prototype._addRoute = function _addRoute(path, handler, segments) {
guardComponent(path, handler);
handler.path = path;
handler.fullPath = (segments.reduce(function (path, segment) {
return path + segment.path;
}, '') + path).replace('//', '/');
segments.push({
path: path,
handler: handler
});
this._recognizer.add(segments, {
as: handler.name
});
// add sub routes
if (handler.subRoutes) {
for (var subPath in handler.subRoutes) {
// recursively walk all sub routes
this._addRoute(subPath, handler.subRoutes[subPath],
// pass a copy in recursion to avoid mutating
// across branches
segments.slice());
}
}
};
/**
* Set the notFound route handler.
*
* @param {Object} handler
*/
Router.prototype._notFound = function _notFound(handler) {
guardComponent('*', handler);
this._notFoundHandler = [{ handler: handler }];
};
/**
* Add a redirect record.
*
* @param {String} path
* @param {String} redirectPath
*/
Router.prototype._addRedirect = function _addRedirect(path, redirectPath) {
if (path === '*') {
this._notFoundRedirect = redirectPath;
} else {
this._addGuard(path, redirectPath, this.replace);
}
};
/**
* Add an alias record.
*
* @param {String} path
* @param {String} aliasPath
*/
Router.prototype._addAlias = function _addAlias(path, aliasPath) {
this._addGuard(path, aliasPath, this._match);
};
/**
* Add a path guard.
*
* @param {String} path
* @param {String} mappedPath
* @param {Function} handler
*/
Router.prototype._addGuard = function _addGuard(path, mappedPath, _handler) {
var _this = this;
this._guardRecognizer.add([{
path: path,
handler: function handler(match, query) {
var realPath = _util.mapParams(mappedPath, match.params, query);
_handler.call(_this, realPath);
}
}]);
};
/**
* Check if a path matches any redirect records.
*
* @param {String} path
* @return {Boolean} - if true, will skip normal match.
*/
Router.prototype._checkGuard = function _checkGuard(path) {
var matched = this._guardRecognizer.recognize(path);
if (matched) {
matched[0].handler(matched[0], matched.queryParams);
return true;
} else if (this._notFoundRedirect) {
matched = this._recognizer.recognize(path);
if (!matched) {
this.replace(this._notFoundRedirect);
return true;
}
}
};
/**
* Match a URL path and set the route context on vm,
* triggering view updates.
*
* @param {String} path
* @param {Object} [state]
* @param {String} [anchor]
*/
Router.prototype._match = function _match(path, state, anchor) {
var _this2 = this;
if (this._checkGuard(path)) {
return;
}
var currentRoute = this._currentRoute;
var currentTransition = this._currentTransition;
if (currentTransition) {
if (currentTransition.to.path === path) {
// do nothing if we have an active transition going to the same path
return;
} else if (currentRoute.path === path) {
// We are going to the same path, but we also have an ongoing but
// not-yet-validated transition. Abort that transition and reset to
// prev transition.
currentTransition.aborted = true;
this._currentTransition = this._prevTransition;
return;
} else {
// going to a totally different path. abort ongoing transition.
currentTransition.aborted = true;
}
}
// construct new route and transition context
var route = new _route2['default'](path, this);
var transition = new _transition2['default'](this, route, currentRoute);
// current transition is updated right now.
// however, current route will only be updated after the transition has
// been validated.
this._prevTransition = currentTransition;
this._currentTransition = transition;
if (!this.app) {
// initial render
this.app = new this._appConstructor({
el: this._appContainer,
_meta: {
$route: route
}
});
}
// check global before hook
var beforeHooks = this._beforeEachHooks;
var startTransition = function startTransition() {
transition.start(function () {
_this2._postTransition(route, state, anchor);
});
};
if (beforeHooks.length) {
transition.runQueue(beforeHooks, function (hook, _, next) {
if (transition === _this2._currentTransition) {
transition.callHook(hook, null, next, {
expectBoolean: true
});
}
}, startTransition);
} else {
startTransition();
}
if (!this._rendered && this._startCb) {
this._startCb.call(null);
}
// HACK:
// set rendered to true after the transition start, so
// that components that are acitvated synchronously know
// whether it is the initial render.
this._rendered = true;
};
/**
* Set current to the new transition.
* This is called by the transition object when the
* validation of a route has succeeded.
*
* @param {Transition} transition
*/
Router.prototype._onTransitionValidated = function _onTransitionValidated(transition) {
// set current route
var route = this._currentRoute = transition.to;
// update route context for all children
if (this.app.$route !== route) {
this.app.$route = route;
this._children.forEach(function (child) {
child.$route = route;
});
}
// call global after hook
if (this._afterEachHooks.length) {
this._afterEachHooks.forEach(function (hook) {
return hook.call(null, {
to: transition.to,
from: transition.from
});
});
}
this._currentTransition.done = true;
};
/**
* Handle stuff after the transition.
*
* @param {Route} route
* @param {Object} [state]
* @param {String} [anchor]
*/
Router.prototype._postTransition = function _postTransition(route, state, anchor) {
// handle scroll positions
// saved scroll positions take priority
// then we check if the path has an anchor
var pos = state && state.pos;
if (pos && this._saveScrollPosition) {
Vue.nextTick(function () {
window.scrollTo(pos.x, pos.y);
});
} else if (anchor) {
Vue.nextTick(function () {
var el = document.getElementById(anchor.slice(1));
if (el) {
window.scrollTo(window.scrollX, el.offsetTop);
}
});
}
};
/**
* Normalize named route object / string paths into
* a string.
*
* @param {Object|String|Number} path
* @return {String}
*/
Router.prototype._stringifyPath = function _stringifyPath(path) {
if (path && typeof path === 'object') {
if (path.name) {
var params = path.params || {};
if (path.query) {
params.queryParams = path.query;
}
return this._recognizer.generate(path.name, params);
} else if (path.path) {
return path.path;
} else {
return '';
}
} else {
return path ? path + '' : '';
}
};
return Router;
})();
function guardComponent(path, handler) {
var comp = handler.component;
if (Vue.util.isPlainObject(comp)) {
comp = handler.component = Vue.extend(comp);
}
/* istanbul ignore if */
if (typeof comp !== 'function') {
handler.component = null;
_util.warn('invalid component for route "' + path + '".');
}
}
/* Installation */
Router.installed = false;
/**
* Installation interface.
* Install the necessary directives.
*/
Router.install = function (externalVue) {
/* istanbul ignore if */
if (Router.installed) {
_util.warn('already installed.');
return;
}
Vue = externalVue;
_override2['default'](Vue);
_directivesView2['default'](Vue);
_directivesLink2['default'](Vue);
_util2['default'].Vue = Vue;
Router.installed = true;
};
// auto install
/* istanbul ignore if */
if (typeof window !== 'undefined' && window.Vue) {
window.Vue.use(Router);
}
exports['default'] = Router;
module.exports = exports['default'];
/***/ },
/* 1 */
/***/ function(module, exports) {
"use strict";
exports["default"] = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
exports.__esModule = true;
/***/ },
/* 2 */
/***/ function(module, exports) {
"use strict";
exports["default"] = function (obj) {
return obj && obj.__esModule ? obj : {
"default": obj
};
};
exports.__esModule = true;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(2)['default'];
exports.__esModule = true;
exports.warn = warn;
exports.resolvePath = resolvePath;
exports.isPromise = isPromise;
exports.getRouteConfig = getRouteConfig;
exports.resolveAsyncComponent = resolveAsyncComponent;
exports.mapParams = mapParams;
var _routeRecognizer = __webpack_require__(4);
var _routeRecognizer2 = _interopRequireDefault(_routeRecognizer);
var genQuery = _routeRecognizer2['default'].prototype.generateQueryString;
// export default for holding the Vue reference
var _exports = {};
exports['default'] = _exports;
/**
* Warn stuff.
*
* @param {String} msg
*/
function warn(msg) {
/* istanbul ignore next */
if (window.console) {
console.warn('[vue-router] ' + msg);
/* istanbul ignore if */
if (!_exports.Vue || _exports.Vue.config.debug) {
console.warn(new Error('warning stack trace:').stack);
}
}
}
/**
* Resolve a relative path.
*
* @param {String} base
* @param {String} relative
* @param {Boolean} append
* @return {String}
*/
function resolvePath(base, relative, append) {
var query = base.match(/(\?.*)$/);
if (query) {
query = query[1];
base = base.slice(0, -query.length);
}
// a query!
if (relative.charAt(0) === '?') {
return base + relative;
}
var stack = base.split('/');
// remove trailing segment if:
// - not appending
// - appending to trailing slash (last segment is empty)
if (!append || !stack[stack.length - 1]) {
stack.pop();
}
// resolve relative path
var segments = relative.replace(/^\//, '').split('/');
for (var i = 0; i < segments.length; i++) {
var segment = segments[i];
if (segment === '.') {
continue;
} else if (segment === '..') {
stack.pop();
} else {
stack.push(segment);
}
}
// ensure leading slash
if (stack[0] !== '') {
stack.unshift('');
}
return stack.join('/');
}
/**
* Forgiving check for a promise
*
* @param {Object} p
* @return {Boolean}
*/
function isPromise(p) {
return p && typeof p.then === 'function';
}
/**
* Retrive a route config field from a component instance
* OR a component contructor.
*
* @param {Function|Vue} component
* @param {String} name
* @return {*}
*/
function getRouteConfig(component, name) {
var options = component && (component.$options || component.options);
return options && options.route && options.route[name];
}
/**
* Resolve an async component factory. Have to do a dirty
* mock here because of Vue core's internal API depends on
* an ID check.
*
* @param {Object} handler
* @param {Function} cb
*/
var resolver = undefined;
function resolveAsyncComponent(handler, cb) {
if (!resolver) {
resolver = {
resolve: _exports.Vue.prototype._resolveComponent,
$options: {
components: {
_: handler.component
}
}
};
} else {
resolver.$options.components._ = handler.component;
}
resolver.resolve('_', function (Component) {
handler.component = Component;
cb(Component);
});
}
/**
* Map the dynamic segments in a path to params.
*
* @param {String} path
* @param {Object} params
* @param {Object} query
*/
function mapParams(path, params, query) {
if (params === undefined) params = {};
path = path.replace(/:([^\/]+)/g, function (_, key) {
var val = params[key];
if (!val) {
warn('param "' + key + '" not found when generating ' + 'path for "' + path + '" with params ' + JSON.stringify(params));
}
return val || '';
});
if (query) {
path += genQuery(query);
}
return path;
}
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {(function() {
"use strict";
function $$route$recognizer$dsl$$Target(path, matcher, delegate) {
this.path = path;
this.matcher = matcher;
this.delegate = delegate;
}
$$route$recognizer$dsl$$Target.prototype = {
to: function(target, callback) {
var delegate = this.delegate;
if (delegate && delegate.willAddRoute) {
target = delegate.willAddRoute(this.matcher.target, target);
}
this.matcher.add(this.path, target);
if (callback) {
if (callback.length === 0) { throw new Error("You must have an argument in the function passed to `to`"); }
this.matcher.addChild(this.path, target, callback, this.delegate);
}
return this;
}
};
function $$route$recognizer$dsl$$Matcher(target) {
this.routes = {};
this.children = {};
this.target = target;
}
$$route$recognizer$dsl$$Matcher.prototype = {
add: function(path, handler) {
this.routes[path] = handler;
},
addChild: function(path, target, callback, delegate) {
var matcher = new $$route$recognizer$dsl$$Matcher(target);
this.children[path] = matcher;
var match = $$route$recognizer$dsl$$generateMatch(path, matcher, delegate);
if (delegate && delegate.contextEntered) {
delegate.contextEntered(target, match);
}
callback(match);
}
};
function $$route$recognizer$dsl$$generateMatch(startingPath, matcher, delegate) {
return function(path, nestedCallback) {
var fullPath = startingPath + path;
if (nestedCallback) {
nestedCallback($$route$recognizer$dsl$$generateMatch(fullPath, matcher, delegate));
} else {
return new $$route$recognizer$dsl$$Target(startingPath + path, matcher, delegate);
}
};
}
function $$route$recognizer$dsl$$addRoute(routeArray, path, handler) {
var len = 0;
for (var i=0, l=routeArray.length; i<l; i++) {
len += routeArray[i].path.length;
}
path = path.substr(len);
var route = { path: path, handler: handler };
routeArray.push(route);
}
function $$route$recognizer$dsl$$eachRoute(baseRoute, matcher, callback, binding) {
var routes = matcher.routes;
for (var path in routes) {
if (routes.hasOwnProperty(path)) {
var routeArray = baseRoute.slice();
$$route$recognizer$dsl$$addRoute(routeArray, path, routes[path]);
if (matcher.children[path]) {
$$route$recognizer$dsl$$eachRoute(routeArray, matcher.children[path], callback, binding);
} else {
callback.call(binding, routeArray);
}
}
}
}
var $$route$recognizer$dsl$$default = function(callback, addRouteCallback) {
var matcher = new $$route$recognizer$dsl$$Matcher();
callback($$route$recognizer$dsl$$generateMatch("", matcher, this.delegate));
$$route$recognizer$dsl$$eachRoute([], matcher, function(route) {
if (addRouteCallback) { addRouteCallback(this, route); }
else { this.add(route); }
}, this);
};
var $$route$recognizer$$specials = [
'/', '.', '*', '+', '?', '|',
'(', ')', '[', ']', '{', '}', '\\'
];
var $$route$recognizer$$escapeRegex = new RegExp('(\\' + $$route$recognizer$$specials.join('|\\') + ')', 'g');
function $$route$recognizer$$isArray(test) {
return Object.prototype.toString.call(test) === "[object Array]";
}
// A Segment represents a segment in the original route description.
// Each Segment type provides an `eachChar` and `regex` method.
//
// The `eachChar` method invokes the callback with one or more character
// specifications. A character specification consumes one or more input
// characters.
//
// The `regex` method returns a regex fragment for the segment. If the
// segment is a dynamic of star segment, the regex fragment also includes
// a capture.
//
// A character specification contains:
//
// * `validChars`: a String with a list of all valid characters, or
// * `invalidChars`: a String with a list of all invalid characters
// * `repeat`: true if the character specification can repeat
function $$route$recognizer$$StaticSegment(string) { this.string = string; }
$$route$recognizer$$StaticSegment.prototype = {
eachChar: function(callback) {
var string = this.string, ch;
for (var i=0, l=string.length; i<l; i++) {
ch = string.charAt(i);
callback({ validChars: ch });
}
},
regex: function() {
return this.string.replace($$route$recognizer$$escapeRegex, '\\$1');
},
generate: function() {
return this.string;
}
};
function $$route$recognizer$$DynamicSegment(name) { this.name = name; }
$$route$recognizer$$DynamicSegment.prototype = {
eachChar: function(callback) {
callback({ invalidChars: "/", repeat: true });
},
regex: function() {
return "([^/]+)";
},
generate: function(params) {
return params[this.name];
}
};
function $$route$recognizer$$StarSegment(name) { this.name = name; }
$$route$recognizer$$StarSegment.prototype = {
eachChar: function(callback) {
callback({ invalidChars: "", repeat: true });
},
regex: function() {
return "(.+)";
},
generate: function(params) {
return params[this.name];
}
};
function $$route$recognizer$$EpsilonSegment() {}
$$route$recognizer$$EpsilonSegment.prototype = {
eachChar: function() {},
regex: function() { return ""; },
generate: function() { return ""; }
};
function $$route$recognizer$$parse(route, names, specificity) {
// normalize route as not starting with a "/". Recognition will
// also normalize.
if (route.charAt(0) === "/") { route = route.substr(1); }
var segments = route.split("/"), results = [];
// A routes has specificity determined by the order that its different segments
// appear in. This system mirrors how the magnitude of numbers written as strings
// works.
// Consider a number written as: "abc". An example would be "200". Any other number written
// "xyz" will be smaller than "abc" so long as `a > z`. For instance, "199" is smaller
// then "200", even though "y" and "z" (which are both 9) are larger than "0" (the value
// of (`b` and `c`). This is because the leading symbol, "2", is larger than the other
// leading symbol, "1".
// The rule is that symbols to the left carry more weight than symbols to the right
// when a number is written out as a string. In the above strings, the leading digit
// represents how many 100's are in the number, and it carries more weight than the middle
// number which represents how many 10's are in the number.
// This system of number magnitude works well for route specificity, too. A route written as
// `a/b/c` will be more specific than `x/y/z` as long as `a` is more specific than
// `x`, irrespective of the other parts.
// Because of this similarity, we assign each type of segment a number value written as a
// string. We can find the specificity of compound routes by concatenating these strings
// together, from left to right. After we have looped through all of the segments,
// we convert the string to a number.
specificity.val = '';
for (var i=0, l=segments.length; i<l; i++) {
var segment = segments[i], match;
if (match = segment.match(/^:([^\/]+)$/)) {
results.push(new $$route$recognizer$$DynamicSegment(match[1]));
names.push(match[1]);
specificity.val += '3';
} else if (match = segment.match(/^\*([^\/]+)$/)) {
results.push(new $$route$recognizer$$StarSegment(match[1]));
specificity.val += '2';
names.push(match[1]);
} else if(segment === "") {
results.push(new $$route$recognizer$$EpsilonSegment());
specificity.val += '1';
} else {
results.push(new $$route$recognizer$$StaticSegment(segment));
specificity.val += '4';
}
}
specificity.val = +specificity.val;
return results;
}
// A State has a character specification and (`charSpec`) and a list of possible
// subsequent states (`nextStates`).
//
// If a State is an accepting state, it will also have several additional
// properties:
//
// * `regex`: A regular expression that is used to extract parameters from paths
// that reached this accepting state.
// * `handlers`: Information on how to convert the list of captures into calls
// to registered handlers with the specified parameters
// * `types`: How many static, dynamic or star segments in this route. Used to
// decide which route to use if multiple registered routes match a path.
//
// Currently, State is implemented naively by looping over `nextStates` and
// comparing a character specification against a character. A more efficient
// implementation would use a hash of keys pointing at one or more next states.
function $$route$recognizer$$State(charSpec) {
this.charSpec = charSpec;
this.nextStates = [];
}
$$route$recognizer$$State.prototype = {
get: function(charSpec) {
var nextStates = this.nextStates;
for (var i=0, l=nextStates.length; i<l; i++) {
var child = nextStates[i];
var isEqual = child.charSpec.validChars === charSpec.validChars;
isEqual = isEqual && child.charSpec.invalidChars === charSpec.invalidChars;
if (isEqual) { return child; }
}
},
put: function(charSpec) {
var state;
// If the character specification already exists in a child of the current
// state, just return that state.
if (state = this.get(charSpec)) { return state; }
// Make a new state for the character spec
state = new $$route$recognizer$$State(charSpec);
// Insert the new state as a child of the current state
this.nextStates.push(state);
// If this character specification repeats, insert the new state as a child
// of itself. Note that this will not trigger an infinite loop because each
// transition during recognition consumes a character.
if (charSpec.repeat) {
state.nextStates.push(state);
}
// Return the new state
return state;
},
// Find a list of child states matching the next character
match: function(ch) {
// DEBUG "Processing `" + ch + "`:"
var nextStates = this.nextStates,
child, charSpec, chars;
// DEBUG " " + debugState(this)
var returned = [];
for (var i=0, l=nextStates.length; i<l; i++) {
child = nextStates[i];
charSpec = child.charSpec;
if (typeof (chars = charSpec.validChars) !== 'undefined') {
if (chars.indexOf(ch) !== -1) { returned.push(child); }
} else if (typeof (chars = charSpec.invalidChars) !== 'undefined') {
if (chars.indexOf(ch) === -1) { returned.push(child); }
}
}
return returned;
}
/** IF DEBUG
, debug: function() {
var charSpec = this.charSpec,
debug = "[",
chars = charSpec.validChars || charSpec.invalidChars;
if (charSpec.invalidChars) { debug += "^"; }
debug += chars;
debug += "]";
if (charSpec.repeat) { debug += "+"; }
return debug;
}
END IF **/
};
/** IF DEBUG
function debug(log) {
console.log(log);
}
function debugState(state) {
return state.nextStates.map(function(n) {
if (n.nextStates.length === 0) { return "( " + n.debug() + " [accepting] )"; }
return "( " + n.debug() + " <then> " + n.nextStates.map(function(s) { return s.debug() }).join(" or ") + " )";
}).join(", ")
}
END IF **/
// Sort the routes by specificity
function $$route$recognizer$$sortSolutions(states) {
return states.sort(function(a, b) {
return b.specificity.val - a.specificity.val;
});
}
function $$route$recognizer$$recognizeChar(states, ch) {
var nextStates = [];
for (var i=0, l=states.length; i<l; i++) {
var state = states[i];
nextStates = nextStates.concat(state.match(ch));
}
return nextStates;
}
var $$route$recognizer$$oCreate = Object.create || function(proto) {
function F() {}
F.prototype = proto;
return new F();
};
function $$route$recognizer$$RecognizeResults(queryParams) {
this.queryParams = queryParams || {};
}
$$route$recognizer$$RecognizeResults.prototype = $$route$recognizer$$oCreate({
splice: Array.prototype.splice,
slice: Array.prototype.slice,
push: Array.prototype.push,
length: 0,
queryParams: null
});
function $$route$recognizer$$findHandler(state, path, queryParams) {
var handlers = state.handlers, regex = state.regex;
var captures = path.match(regex), currentCapture = 1;
var result = new $$route$recognizer$$RecognizeResults(queryParams);
for (var i=0, l=handlers.length; i<l; i++) {
var handler = handlers[i], names = handler.names, params = {};
for (var j=0, m=names.length; j<m; j++) {
params[names[j]] = captures[currentCapture++];
}
result.push({ handler: handler.handler, params: params, isDynamic: !!names.length });
}
return result;
}
function $$route$recognizer$$addSegment(currentState, segment) {
segment.eachChar(function(ch) {
var state;
currentState = currentState.put(ch);
});
return currentState;
}
function $$route$recognizer$$decodeQueryParamPart(part) {
// http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
part = part.replace(/\+/gm, '%20');
return decodeURIComponent(part);
}
// The main interface
var $$route$recognizer$$RouteRecognizer = function() {
this.rootState = new $$route$recognizer$$State();
this.names = {};
};
$$route$recognizer$$RouteRecognizer.prototype = {
add: function(routes, options) {
var currentState = this.rootState, regex = "^",
specificity = {},
handlers = [], allSegments = [], name;
var isEmpty = true;
for (var i=0, l=routes.length; i<l; i++) {
var route = routes[i], names = [];
var segments = $$route$recognizer$$parse(route.path, names, specificity);
allSegments = allSegments.concat(segments);
for (var j=0, m=segments.length; j<m; j++) {
var segment = segments[j];
if (segment instanceof $$route$recognizer$$EpsilonSegment) { continue; }
isEmpty = false;
// Add a "/" for the new segment
currentState = currentState.put({ validChars: "/" });
regex += "/";
// Add a representation of the segment to the NFA and regex
currentState = $$route$recognizer$$addSegment(currentState, segment);
regex += segment.regex();
}
var handler = { handler: route.handler, names: names };
handlers.push(handler);
}
if (isEmpty) {
currentState = currentState.put({ validChars: "/" });
regex += "/";
}
currentState.handlers = handlers;
currentState.regex = new RegExp(regex + "$");
currentState.specificity = specificity;
if (name = options && options.as) {
this.names[name] = {
segments: allSegments,
handlers: handlers
};
}
},
handlersFor: function(name) {
var route = this.names[name], result = [];
if (!route) { throw new Error("There is no route named " + name); }
for (var i=0, l=route.handlers.length; i<l; i++) {
result.push(route.handlers[i]);
}
return result;
},
hasRoute: function(name) {
return !!this.names[name];
},
generate: function(name, params) {
var route = this.names[name], output = "";
if (!route) { throw new Error("There is no route named " + name); }
var segments = route.segments;
for (var i=0, l=segments.length; i<l; i++) {
var segment = segments[i];
if (segment instanceof $$route$recognizer$$EpsilonSegment) { continue; }
output += "/";
output += segment.generate(params);
}
if (output.charAt(0) !== '/') { output = '/' + output; }
if (params && params.queryParams) {
output += this.generateQueryString(params.queryParams, route.handlers);
}
return output;
},
generateQueryString: function(params, handlers) {
var pairs = [];
var keys = [];
for(var key in params) {
if (params.hasOwnProperty(key)) {
keys.push(key);
}
}
keys.sort();
for (var i = 0, len = keys.length; i < len; i++) {
key = keys[i];
var value = params[key];
if (value == null) {
continue;
}
var pair = encodeURIComponent(key);
if ($$route$recognizer$$isArray(value)) {
for (var j = 0, l = value.length; j < l; j++) {
var arrayPair = key + '[]' + '=' + encodeURIComponent(value[j]);
pairs.push(arrayPair);
}
} else {
pair += "=" + encodeURIComponent(value);
pairs.push(pair);
}
}
if (pairs.length === 0) { return ''; }
return "?" + pairs.join("&");
},
parseQueryString: function(queryString) {
var pairs = queryString.split("&"), queryParams = {};
for(var i=0; i < pairs.length; i++) {
var pair = pairs[i].split('='),
key = $$route$recognizer$$decodeQueryParamPart(pair[0]),
keyLength = key.length,
isArray = false,
value;
if (pair.length === 1) {
value = 'true';
} else {
//Handle arrays
if (keyLength > 2 && key.slice(keyLength -2) === '[]') {
isArray = true;
key = key.slice(0, keyLength - 2);
if(!queryParams[key]) {
queryParams[key] = [];
}
}
value = pair[1] ? $$route$recognizer$$decodeQueryParamPart(pair[1]) : '';
}
if (isArray) {
queryParams[key].push(value);
} else {
queryParams[key] = value;
}
}
return queryParams;
},
recognize: function(path) {
var states = [ this.rootState ],
pathLen, i, l, queryStart, queryParams = {},
isSlashDropped = false;
queryStart = path.indexOf('?');
if (queryStart !== -1) {
var queryString = path.substr(queryStart + 1, path.length);
path = path.substr(0, queryStart);
queryParams = this.parseQueryString(queryString);
}
path = decodeURI(path);
// DEBUG GROUP path
if (path.charAt(0) !== "/") { path = "/" + path; }
pathLen = path.length;
if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
path = path.substr(0, pathLen - 1);
isSlashDropped = true;
}
for (i=0, l=path.length; i<l; i++) {
states = $$route$recognizer$$recognizeChar(states, path.charAt(i));
if (!states.length) { break; }
}
// END DEBUG GROUP
var solutions = [];
for (i=0, l=states.length; i<l; i++) {
if (states[i].handlers) { solutions.push(states[i]); }
}
states = $$route$recognizer$$sortSolutions(solutions);
var state = solutions[0];
if (state && state.handlers) {
// if a trailing slash was dropped and a star segment is the last segment
// specified, put the trailing slash back
if (isSlashDropped && state.regex.source.slice(-5) === "(.+)$") {
path = path + "/";
}
return $$route$recognizer$$findHandler(state, path, queryParams);
}
}
};
$$route$recognizer$$RouteRecognizer.prototype.map = $$route$recognizer$dsl$$default;
$$route$recognizer$$RouteRecognizer.VERSION = '0.1.9';
var $$route$recognizer$$default = $$route$recognizer$$RouteRecognizer;
/* global define:true module:true window: true */
if ("function" === 'function' && __webpack_require__(6)['amd']) {
!(__WEBPACK_AMD_DEFINE_RESULT__ = function() { return $$route$recognizer$$default; }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if (typeof module !== 'undefined' && module['exports']) {
module['exports'] = $$route$recognizer$$default;
} else if (typeof this !== 'undefined') {
this['RouteRecognizer'] = $$route$recognizer$$default;
}
}).call(this);
//# sourceMappingURL=route-recognizer.js.map
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)(module)))
/***/ },
/* 5 */
/***/ function(module, exports) {
module.exports = function(module) {
if(!module.webpackPolyfill) {
module.deprecate = function() {};
module.paths = [];
// module.parent = undefined by default
module.children = [];
module.webpackPolyfill = 1;
}
return module;
}
/***/ },
/* 6 */
/***/ function(module, exports) {
module.exports = function() { throw new Error("define cannot be used indirect"); };
/***/ },
/* 7 */
/***/ function(module, exports) {
'use strict';
exports.__esModule = true;
exports['default'] = function (Vue) {
var _ = Vue.util;
// override Vue's init and destroy process to keep track of router instances
var init = Vue.prototype._init;
Vue.prototype._init = function (options) {
var root = options._parent || options.parent || this;
var route = root.$route;
if (route) {
route.router._children.push(this);
if (!this.$route) {
/* istanbul ignore if */
if (this._defineMeta) {
// 0.12
this._defineMeta('$route', route);
} else {
// 1.0
_.defineReactive(this, '$route', route);
}
}
}
init.call(this, options);
};
var destroy = Vue.prototype._destroy;
Vue.prototype._destroy = function () {
if (!this._isBeingDestroyed) {
var route = this.$root.$route;
if (route) {
route.router._children.$remove(this);
}
destroy.apply(this, arguments);
}
};
// 1.0 only: enable route mixins
var strats = Vue.config.optionMergeStrategies;
var hooksToMergeRE = /^(data|activate|deactivate)$/;
if (strats) {
strats.route = function (parentVal, childVal) {
if (!childVal) return parentVal;
if (!parentVal) return childVal;
var ret = {};
_.extend(ret, parentVal);
for (var key in childVal) {
var a = ret[key];
var b = childVal[key];
// for data, activate and deactivate, we need to merge them into
// arrays similar to lifecycle hooks.
if (a && hooksToMergeRE.test(key)) {
ret[key] = (_.isArray(a) ? a : [a]).concat(b);
} else {
ret[key] = b;
}
}
return ret;
};
}
};
module.exports = exports['default'];
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _classCallCheck = __webpack_require__(1)["default"];
var _Object$freeze = __webpack_require__(9)["default"];
exports.__esModule = true;
var internalKeysRE = /^(component|subRoutes)$/;
/**
* Route Context Object
*
* @param {String} path
* @param {Router} router
*/
var Route = function Route(path, router) {
var _this = this;
_classCallCheck(this, Route);
var matched = router._recognizer.recognize(path);
if (matched) {
// copy all custom fields from route configs
[].forEach.call(matched, function (match) {
for (var key in match.handler) {
if (!internalKeysRE.test(key)) {
_this[key] = match.handler[key];
}
}
});
// set query and params
this.query = matched.queryParams;
this.params = [].reduce.call(matched, function (prev, cur) {
if (cur.params) {
for (var key in cur.params) {
prev[key] = cur.params[key];
}
}
return prev;
}, {});
}
// expose path and router
this.path = path;
this.router = router;
// for internal use
this.matched = matched || router._notFoundHandler;
// Important: freeze self to prevent observation
_Object$freeze(this);
};
exports["default"] = Route;
module.exports = exports["default"];
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(10), __esModule: true };
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(11);
module.exports = __webpack_require__(16).Object.freeze;
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.5 Object.freeze(O)
var isObject = __webpack_require__(12);
__webpack_require__(13)('freeze', function($freeze){
return function freeze(it){
return $freeze && isObject(it) ? $freeze(it) : it;
};
});
/***/ },
/* 12 */
/***/ function(module, exports) {
// http://jsperf.com/core-js-isobject
module.exports = function(it){
return it !== null && (typeof it == 'object' || typeof it == 'function');
};
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
// most Object methods by ES6 should accept primitives
module.exports = function(KEY, exec){
var $def = __webpack_require__(14)
, fn = (__webpack_require__(16).Object || {})[KEY] || Object[KEY]
, exp = {};
exp[KEY] = exec(fn);
$def($def.S + $def.F * __webpack_require__(17)(function(){ fn(1); }), 'Object', exp);
};
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(15)
, core = __webpack_require__(16)
, PROTOTYPE = 'prototype';
var ctx = function(fn, that){
return function(){
return fn.apply(that, arguments);
};
};
var $def = function(type, name, source){
var key, own, out, exp
, isGlobal = type & $def.G
, isProto = type & $def.P
, target = isGlobal ? global : type & $def.S
? global[name] : (global[name] || {})[PROTOTYPE]
, exports = isGlobal ? core : core[name] || (core[name] = {});
if(isGlobal)source = name;
for(key in source){
// contains in native
own = !(type & $def.F) && target && key in target;
if(own && key in exports)continue;
// export native or passed
out = own ? target[key] : source[key];
// prevent global pollution for namespaces
if(isGlobal && typeof target[key] != 'function')exp = source[key];
// bind timers to global for call from export context
else if(type & $def.B && own)exp = ctx(out, global);
// wrap global constructors for prevent change them in library
else if(type & $def.W && target[key] == out)!function(C){
exp = function(param){
return this instanceof C ? new C(param) : C(param);
};
exp[PROTOTYPE] = C[PROTOTYPE];
}(out);
else exp = isProto && typeof out == 'function' ? ctx(Function.call, out) : out;
// export
exports[key] = exp;
if(isProto)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
}
};
// type bitmap
$def.F = 1; // forced
$def.G = 2; // global
$def.S = 4; // static
$def.P = 8; // proto
$def.B = 16; // bind
$def.W = 32; // wrap
module.exports = $def;
/***/ },
/* 15 */
/***/ function(module, exports) {
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var UNDEFINED = 'undefined';
var global = module.exports = typeof window != UNDEFINED && window.Math == Math
? window : typeof self != UNDEFINED && self.Math == Math ? self : Function('return this')();
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
/***/ },
/* 16 */
/***/ function(module, exports) {
var core = module.exports = {};
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
/***/ },
/* 17 */
/***/ function(module, exports) {
module.exports = function(exec){
try {
return !!exec();
} catch(e){
return true;
}
};
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _classCallCheck = __webpack_require__(1)['default'];
exports.__esModule = true;
var _util = __webpack_require__(3);
var _pipeline = __webpack_require__(19);
/**
* A RouteTransition object manages the pipeline of a
* router-view switching process. This is also the object
* passed into user route hooks.
*
* @param {Router} router
* @param {Route} to
* @param {Route} from
*/
var RouteTransition = (function () {
function RouteTransition(router, to, from) {
_classCallCheck(this, RouteTransition);
this.router = router;
this.to = to;
this.from = from;
this.next = null;
this.aborted = false;
this.done = false;
// start by determine the queues
// the deactivate queue is an array of router-view
// directive instances that need to be deactivated,
// deepest first.
this.deactivateQueue = router._views;
// check the default handler of the deepest match
var matched = to.matched ? Array.prototype.slice.call(to.matched) : [];
// the activate queue is an array of route handlers
// that need to be activated
this.activateQueue = matched.map(function (match) {
return match.handler;
});
}
/**
* Abort current transition and return to previous location.
*/
RouteTransition.prototype.abort = function abort() {
if (!this.aborted) {
this.aborted = true;
// if the root path throws an error during validation
// on initial load, it gets caught in an infinite loop.
var abortingOnLoad = !this.from.path && this.to.path === '/';
if (!abortingOnLoad) {
this.router.replace(this.from.path || '/');
}
}
};
/**
* Abort current transition and redirect to a new location.
*
* @param {String} path
*/
RouteTransition.prototype.redirect = function redirect(path) {
if (!this.aborted) {
this.aborted = true;
if (typeof path === 'string') {
path = _util.mapParams(path, this.to.params, this.to.query);
} else {
path.params = this.to.params;
path.query = this.to.query;
}
this.router.replace(path);
}
};
/**
* A router view transition's pipeline can be described as
* follows, assuming we are transitioning from an existing
* <router-view> chain [Component A, Component B] to a new
* chain [Component A, Component C]:
*
* A A
* | => |
* B C
*
* 1. Reusablity phase:
* -> canReuse(A, A)
* -> canReuse(B, C)
* -> determine new queues:
* - deactivation: [B]
* - activation: [C]
*
* 2. Validation phase:
* -> canDeactivate(B)
* -> canActivate(C)
*
* 3. Activation phase:
* -> deactivate(B)
* -> activate(C)
*
* Each of these steps can be asynchronous, and any
* step can potentially abort the transition.
*
* @param {Function} cb
*/
RouteTransition.prototype.start = function start(cb) {
var transition = this;
var daq = this.deactivateQueue;
var aq = this.activateQueue;
var rdaq = daq.slice().reverse();
var reuseQueue = undefined;
// 1. Reusability phase
var i = undefined;
for (i = 0; i < rdaq.length; i++) {
if (!_pipeline.canReuse(rdaq[i], aq[i], transition)) {
break;
}
}
if (i > 0) {
reuseQueue = rdaq.slice(0, i);
daq = rdaq.slice(i).reverse();
aq = aq.slice(i);
}
// 2. Validation phase
transition.runQueue(daq, _pipeline.canDeactivate, function () {
transition.runQueue(aq, _pipeline.canActivate, function () {
transition.runQueue(daq, _pipeline.deactivate, function () {
// 3. Activation phase
// Update router current route
transition.router._onTransitionValidated(transition);
// trigger reuse for all reused views
reuseQueue && reuseQueue.forEach(function (view) {
_pipeline.reuse(view, transition);
});
// the root of the chain that needs to be replaced
// is the top-most non-reusable view.
if (daq.length) {
var view = daq[daq.length - 1];
var depth = reuseQueue ? reuseQueue.length : 0;
_pipeline.activate(view, transition, depth, cb);
} else {
cb();
}
});
});
});
};
/**
* Asynchronously and sequentially apply a function to a
* queue.
*
* @param {Array} queue
* @param {Function} fn
* @param {Function} cb
*/
RouteTransition.prototype.runQueue = function runQueue(queue, fn, cb) {
var transition = this;
step(0);
function step(index) {
if (index >= queue.length) {
cb();
} else {
fn(queue[index], transition, function () {
step(index + 1);
});
}
}
};
/**
* Call a user provided route transition hook and handle
* the response (e.g. if the user returns a promise).
*
* If the user neither expects an argument nor returns a
* promise, the hook is assumed to be synchronous.
*
* @param {Function} hook
* @param {*} [context]
* @param {Function} [cb]
* @param {Object} [options]
* - {Boolean} expectBoolean
* - {Boolean} expectData
* - {Function} cleanup
*/
RouteTransition.prototype.callHook = function callHook(hook, context, cb) {
var _ref = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
var _ref$expectBoolean = _ref.expectBoolean;
var expectBoolean = _ref$expectBoolean === undefined ? false : _ref$expectBoolean;
var _ref$expectData = _ref.expectData;
var expectData = _ref$expectData === undefined ? false : _ref$expectData;
var cleanup = _ref.cleanup;
var transition = this;
var nextCalled = false;
// abort the transition
var abort = function abort() {
cleanup && cleanup();
transition.abort();
};
// handle errors
var onError = function onError(err) {
// cleanup indicates an after-activation hook,
// so instead of aborting we just let the transition
// finish.
cleanup ? next() : abort();
if (err && !transition.router._suppress) {
_util.warn('Uncaught error during transition: ');
throw err instanceof Error ? err : new Error(err);
}
};
// advance the transition to the next step
var next = function next(data) {
if (nextCalled) {
_util.warn('transition.next() should be called only once.');
return;
}
nextCalled = true;
if (transition.aborted) {
cleanup && cleanup();
return;
}
cb && cb(data, onError);
};
// expose a clone of the transition object, so that each
// hook gets a clean copy and prevent the user from
// messing with the internals.
var exposed = {
to: transition.to,
from: transition.from,
abort: abort,
next: next,
redirect: function redirect() {
transition.redirect.apply(transition, arguments);
}
};
// actually call the hook
var res = undefined;
try {
res = hook.call(context, exposed);
} catch (err) {
return onError(err);
}
// handle boolean/promise return values
var resIsPromise = _util.isPromise(res);
if (expectBoolean) {
if (typeof res === 'boolean') {
res ? next() : abort();
} else if (resIsPromise) {
res.then(function (ok) {
ok ? next() : abort();
}, onError);
} else if (!hook.length) {
next(res);
}
} else if (resIsPromise) {
res.then(next, onError);
} else if (expectData && isPlainOjbect(res) || !hook.length) {
next(res);
}
};
/**
* Call a single hook or an array of async hooks in series.
*
* @param {Array} hooks
* @param {*} context
* @param {Function} cb
* @param {Object} [options]
*/
RouteTransition.prototype.callHooks = function callHooks(hooks, context, cb, options) {
var _this = this;
if (Array.isArray(hooks)) {
(function () {
var res = [];
res._needMerge = true;
var onError = undefined;
_this.runQueue(hooks, function (hook, _, next) {
if (!_this.aborted) {
_this.callHook(hook, context, function (r, onError) {
if (r) res.push(r);
onError = onError;
next();
}, options);
}
}, function () {
cb(res, onError);
});
})();
} else {
this.callHook(hooks, context, cb, options);
}
};
return RouteTransition;
})();
exports['default'] = RouteTransition;
function isPlainOjbect(val) {
return Object.prototype.toString.call(val) === '[object Object]';
}
module.exports = exports['default'];
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _Object$keys = __webpack_require__(20)['default'];
var _Object$create = __webpack_require__(25)['default'];
exports.__esModule = true;
exports.canReuse = canReuse;
exports.canDeactivate = canDeactivate;
exports.canActivate = canActivate;
exports.deactivate = deactivate;
exports.activate = activate;
exports.reuse = reuse;
var _util = __webpack_require__(3);
/**
* Determine the reusability of an existing router view.
*
* @param {Directive} view
* @param {Object} handler
* @param {Transition} transition
*/
function canReuse(view, handler, transition) {
var component = view.childVM;
if (!component || !handler) {
return false;
}
// important: check view.Component here because it may
// have been changed in activate hook
if (view.Component !== handler.component) {
return false;
}
var canReuseFn = _util.getRouteConfig(component, 'canReuse');
return typeof canReuseFn === 'boolean' ? canReuseFn : canReuseFn ? canReuseFn.call(component, {
to: transition.to,
from: transition.from
}) : true; // defaults to true
}
/**
* Check if a component can deactivate.
*
* @param {Directive} view
* @param {Transition} transition
* @param {Function} next
*/
function canDeactivate(view, transition, next) {
var fromComponent = view.childVM;
var hook = _util.getRouteConfig(fromComponent, 'canDeactivate');
if (!hook) {
next();
} else {
transition.callHook(hook, fromComponent, next, {
expectBoolean: true
});
}
}
/**
* Check if a component can activate.
*
* @param {Object} handler
* @param {Transition} transition
* @param {Function} next
*/
function canActivate(handler, transition, next) {
_util.resolveAsyncComponent(handler, function (Component) {
// have to check due to async-ness
if (transition.aborted) {
return;
}
// determine if this component can be activated
var hook = _util.getRouteConfig(Component, 'canActivate');
if (!hook) {
next();
} else {
transition.callHook(hook, null, next, {
expectBoolean: true
});
}
});
}
/**
* Call deactivate hooks for existing router-views.
*
* @param {Directive} view
* @param {Transition} transition
* @param {Function} next
*/
function deactivate(view, transition, next) {
var component = view.childVM;
var hook = _util.getRouteConfig(component, 'deactivate');
if (!hook) {
next();
} else {
transition.callHooks(hook, component, next);
}
}
/**
* Activate / switch component for a router-view.
*
* @param {Directive} view
* @param {Transition} transition
* @param {Number} depth
* @param {Function} [cb]
*/
function activate(view, transition, depth, cb, reuse) {
var handler = transition.activateQueue[depth];
if (!handler) {
// fix 1.0.0-alpha.3 compat
if (view._bound) {
view.setComponent(null);
}
cb && cb();
return;
}
var Component = view.Component = handler.component;
var activateHook = _util.getRouteConfig(Component, 'activate');
var dataHook = _util.getRouteConfig(Component, 'data');
var waitForData = _util.getRouteConfig(Component, 'waitForData');
view.depth = depth;
view.activated = false;
var component = undefined;
var loading = !!(dataHook && !waitForData);
// "reuse" is a flag passed down when the parent view is
// either reused via keep-alive or as a child of a kept-alive view.
// of course we can only reuse if the current kept-alive instance
// is of the correct type.
reuse = reuse && view.childVM && view.childVM.constructor === Component;
if (reuse) {
// just reuse
component = view.childVM;
component.$loadingRouteData = loading;
} else {
// unbuild current component. this step also destroys
// and removes all nested child views.
view.unbuild(true);
// handle keep-alive.
// if the view has keep-alive, the child vm is not actually
// destroyed - its nested views will still be in router's
// view list. We need to removed these child views and
// cache them on the child vm.
if (view.keepAlive) {
var views = transition.router._views;
var i = views.indexOf(view);
if (i > 0) {
transition.router._views = views.slice(i);
if (view.childVM) {
view.childVM._routerViews = views.slice(0, i);
}
}
}
// build the new component. this will also create the
// direct child view of the current one. it will register
// itself as view.childView.
component = view.build({
_meta: {
$loadingRouteData: loading
}
});
// handle keep-alive.
// when a kept-alive child vm is restored, we need to
// add its cached child views into the router's view list,
// and also properly update current view's child view.
if (view.keepAlive) {
component.$loadingRouteData = loading;
var cachedViews = component._routerViews;
if (cachedViews) {
transition.router._views = cachedViews.concat(transition.router._views);
view.childView = cachedViews[cachedViews.length - 1];
component._routerViews = null;
}
}
}
// cleanup the component in case the transition is aborted
// before the component is ever inserted.
var cleanup = function cleanup() {
component.$destroy();
};
// actually insert the component and trigger transition
var insert = function insert() {
if (reuse) {
cb && cb();
return;
}
var router = transition.router;
if (router._rendered || router._transitionOnLoad) {
view.transition(component);
} else {
// no transition on first render, manual transition
/* istanbul ignore if */
if (view.setCurrent) {
// 0.12 compat
view.setCurrent(component);
} else {
// 1.0
view.childVM = component;
}
component.$before(view.anchor, null, false);
}
cb && cb();
};
// called after activation hook is resolved
var afterActivate = function afterActivate() {
view.activated = true;
// activate the child view
if (view.childView) {
activate(view.childView, transition, depth + 1, null, reuse || view.keepAlive);
}
if (dataHook && waitForData) {
// wait until data loaded to insert
loadData(component, transition, dataHook, insert, cleanup);
} else {
// load data and insert at the same time
if (dataHook) {
loadData(component, transition, dataHook);
}
insert();
}
};
if (activateHook) {
transition.callHooks(activateHook, component, afterActivate, {
cleanup: cleanup
});
} else {
afterActivate();
}
}
/**
* Reuse a view, just reload data if necessary.
*
* @param {Directive} view
* @param {Transition} transition
*/
function reuse(view, transition) {
var component = view.childVM;
var dataHook = _util.getRouteConfig(component, 'data');
if (dataHook) {
loadData(component, transition, dataHook);
}
}
/**
* Asynchronously load and apply data to component.
*
* @param {Vue} component
* @param {Transition} transition
* @param {Function} hook
* @param {Function} cb
* @param {Function} cleanup
*/
function loadData(component, transition, hook, cb, cleanup) {
component.$loadingRouteData = true;
transition.callHooks(hook, component, function (data, onError) {
// merge data from multiple data hooks
if (Array.isArray(data) && data._needMerge) {
data = data.reduce(function (res, obj) {
if (isPlainObject(obj)) {
_Object$keys(obj).forEach(function (key) {
res[key] = obj[key];
});
}
return res;
}, _Object$create(null));
}
// handle promise sugar syntax
var promises = [];
if (isPlainObject(data)) {
_Object$keys(data).forEach(function (key) {
var val = data[key];
if (_util.isPromise(val)) {
promises.push(val.then(function (resolvedVal) {
component.$set(key, resolvedVal);
}));
} else {
component.$set(key, val);
}
});
}
if (!promises.length) {
component.$loadingRouteData = false;
cb && cb();
} else {
promises[0].constructor.all(promises).then(function (_) {
component.$loadingRouteData = false;
cb && cb();
}, onError);
}
}, {
cleanup: cleanup,
expectData: true
});
}
function isPlainObject(obj) {
return Object.prototype.toString.call(obj) === '[object Object]';
}
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(21), __esModule: true };
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(22);
module.exports = __webpack_require__(16).Object.keys;
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.14 Object.keys(O)
var toObject = __webpack_require__(23);
__webpack_require__(13)('keys', function($keys){
return function keys(it){
return $keys(toObject(it));
};
});
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.13 ToObject(argument)
var defined = __webpack_require__(24);
module.exports = function(it){
return Object(defined(it));
};
/***/ },
/* 24 */
/***/ function(module, exports) {
// 7.2.1 RequireObjectCoercible(argument)
module.exports = function(it){
if(it == undefined)throw TypeError("Can't call method on " + it);
return it;
};
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(26), __esModule: true };
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(27);
module.exports = function create(P, D){
return $.create(P, D);
};
/***/ },
/* 27 */
/***/ function(module, exports) {
var $Object = Object;
module.exports = {
create: $Object.create,
getProto: $Object.getPrototypeOf,
isEnum: {}.propertyIsEnumerable,
getDesc: $Object.getOwnPropertyDescriptor,
setDesc: $Object.defineProperty,
setDescs: $Object.defineProperties,
getKeys: $Object.keys,
getNames: $Object.getOwnPropertyNames,
getSymbols: $Object.getOwnPropertySymbols,
each: [].forEach
};
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
exports.__esModule = true;
var _util = __webpack_require__(3);
var _pipeline = __webpack_require__(19);
exports['default'] = function (Vue) {
var _ = Vue.util;
var componentDef =
// 0.12
Vue.directive('_component') ||
// 1.0
Vue.internalDirectives.component;
// <router-view> extends the internal component directive
var viewDef = _.extend({}, componentDef);
// with some overrides
_.extend(viewDef, {
_isRouterView: true,
bind: function bind() {
var route = this.vm.$route;
/* istanbul ignore if */
if (!route) {
_util.warn('<router-view> can only be used inside a ' + 'router-enabled app.');
return;
}
// force dynamic directive so v-component doesn't
// attempt to build right now
this._isDynamicLiteral = true;
// finally, init by delegating to v-component
componentDef.bind.call(this);
// all we need to do here is registering this view
// in the router. actual component switching will be
// managed by the pipeline.
var router = this.router = route.router;
router._views.unshift(this);
// note the views are in reverse order.
var parentView = router._views[1];
if (parentView) {
// register self as a child of the parent view,
// instead of activating now. This is so that the
// child's activate hook is called after the
// parent's has resolved.
parentView.childView = this;
}
// handle late-rendered view
// two possibilities:
// 1. root view rendered after transition has been
// validated;
// 2. child view rendered after parent view has been
// activated.
var transition = route.router._currentTransition;
if (!parentView && transition.done || parentView && parentView.activated) {
var depth = parentView ? parentView.depth + 1 : 0;
_pipeline.activate(this, transition, depth);
}
},
unbind: function unbind() {
this.router._views.$remove(this);
componentDef.unbind.call(this);
}
});
Vue.elementDirective('router-view', viewDef);
};
module.exports = exports['default'];
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
exports.__esModule = true;
var _util = __webpack_require__(3);
var trailingSlashRE = /\/$/;
var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
// install v-link, which provides navigation support for
// HTML5 history mode
exports['default'] = function (Vue) {
var _ = Vue.util;
Vue.directive('link', {
bind: function bind() {
var _this = this;
var vm = this.vm;
/* istanbul ignore if */
if (!vm.$route) {
_util.warn('v-link can only be used inside a ' + 'router-enabled app.');
return;
}
var router = vm.$route.router;
this.handler = function (e) {
// don't redirect with control keys
if (e.metaKey || e.ctrlKey || e.shiftKey) return;
// don't redirect when preventDefault called
if (e.defaultPrevented) return;
// don't redirect on right click
if (e.button !== 0) return;
var target = _this.target;
var go = function go(target) {
e.preventDefault();
if (target != null) {
router.go(target);
}
};
if (_this.el.tagName === 'A' || e.target === _this.el) {
// v-link on <a v-link="'path'">
go(target);
} else {
// v-link delegate on <div v-link>
var el = e.target;
while (el && el.tagName !== 'A' && el !== _this.el) {
el = el.parentNode;
}
if (!el) return;
if (el.tagName !== 'A' || !el.href) {
// allow not anchor
go(target);
} else if (sameOrigin(el)) {
go({
path: el.pathname,
replace: target && target.replace,
append: target && target.append
});
}
}
};
this.el.addEventListener('click', this.handler);
// manage active link class
this.unwatch = vm.$watch('$route.path', _.bind(this.updateClasses, this));
},
update: function update(path) {
var router = this.vm.$route.router;
var append = undefined;
this.target = path;
if (_.isObject(path)) {
append = path.append;
this.exact = path.exact;
this.prevActiveClass = this.activeClass;
this.activeClass = path.activeClass;
}
path = this.path = router._stringifyPath(path);
this.activeRE = path && !this.exact ? new RegExp('^' + path.replace(/\/$/, '').replace(regexEscapeRE, '\\$&') + '(\\/|$)') : null;
this.updateClasses(this.vm.$route.path);
var isAbsolute = path.charAt(0) === '/';
// do not format non-hash relative paths
var href = path && (router.mode === 'hash' || isAbsolute) ? router.history.formatPath(path, append) : path;
if (this.el.tagName === 'A') {
if (href) {
this.el.href = href;
} else {
this.el.removeAttribute('href');
}
}
},
updateClasses: function updateClasses(path) {
var el = this.el;
var dest = this.path;
var router = this.vm.$route.router;
var activeClass = this.activeClass || router._linkActiveClass;
// clear old class
if (this.prevActiveClass !== activeClass) {
_.removeClass(el, this.prevActiveClass);
}
// add new class
if (this.exact) {
if (dest === path ||
// also allow additional trailing slash
dest.charAt(dest.length - 1) !== '/' && dest === path.replace(trailingSlashRE, '')) {
_.addClass(el, activeClass);
} else {
_.removeClass(el, activeClass);
}
} else {
if (this.activeRE && this.activeRE.test(path)) {
_.addClass(el, activeClass);
} else {
_.removeClass(el, activeClass);
}
}
},
unbind: function unbind() {
this.el.removeEventListener('click', this.handler);
this.unwatch && this.unwatch();
}
});
function sameOrigin(link) {
return link.protocol === location.protocol && link.hostname === location.hostname && link.port === location.port;
}
};
module.exports = exports['default'];
/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _classCallCheck = __webpack_require__(1)['default'];
exports.__esModule = true;
var _util = __webpack_require__(3);
var AbstractHistory = (function () {
function AbstractHistory(_ref) {
var onChange = _ref.onChange;
_classCallCheck(this, AbstractHistory);
this.onChange = onChange;
this.currentPath = '/';
}
AbstractHistory.prototype.start = function start() {
this.onChange('/');
};
AbstractHistory.prototype.stop = function stop() {
// noop
};
AbstractHistory.prototype.go = function go(path, replace, append) {
path = this.currentPath = this.formatPath(path, append);
this.onChange(path);
};
AbstractHistory.prototype.formatPath = function formatPath(path, append) {
return path.charAt(0) === '/' ? path : _util.resolvePath(this.currentPath, path, append);
};
return AbstractHistory;
})();
exports['default'] = AbstractHistory;
module.exports = exports['default'];
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _classCallCheck = __webpack_require__(1)['default'];
exports.__esModule = true;
var _util = __webpack_require__(3);
var HashHistory = (function () {
function HashHistory(_ref) {
var hashbang = _ref.hashbang;
var onChange = _ref.onChange;
_classCallCheck(this, HashHistory);
this.hashbang = hashbang;
this.onChange = onChange;
}
HashHistory.prototype.start = function start() {
var self = this;
this.listener = function () {
var path = location.hash;
var raw = path.replace(/^#!?/, '');
// always
if (raw.charAt(0) !== '/') {
raw = '/' + raw;
}
var formattedPath = self.formatPath(raw);
if (formattedPath !== path) {
location.replace(formattedPath);
return;
}
var pathToMatch = decodeURI(path.replace(/^#!?/, '') + location.search);
self.onChange(pathToMatch);
};
window.addEventListener('hashchange', this.listener);
this.listener();
};
HashHistory.prototype.stop = function stop() {
window.removeEventListener('hashchange', this.listener);
};
HashHistory.prototype.go = function go(path, replace, append) {
path = this.formatPath(path, append);
if (replace) {
location.replace(path);
} else {
location.hash = path;
}
};
HashHistory.prototype.formatPath = function formatPath(path, append) {
var isAbsoloute = path.charAt(0) === '/';
var prefix = '#' + (this.hashbang ? '!' : '');
return isAbsoloute ? prefix + path : prefix + _util.resolvePath(location.hash.replace(/^#!?/, ''), path, append);
};
return HashHistory;
})();
exports['default'] = HashHistory;
module.exports = exports['default'];
/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _classCallCheck = __webpack_require__(1)['default'];
exports.__esModule = true;
var _util = __webpack_require__(3);
var hashRE = /#.*$/;
var HTML5History = (function () {
function HTML5History(_ref) {
var root = _ref.root;
var onChange = _ref.onChange;
_classCallCheck(this, HTML5History);
if (root) {
// make sure there's the starting slash
if (root.charAt(0) !== '/') {
root = '/' + root;
}
// remove trailing slash
this.root = root.replace(/\/$/, '');
this.rootRE = new RegExp('^\\' + this.root);
} else {
this.root = null;
}
this.onChange = onChange;
// check base tag
var baseEl = document.querySelector('base');
this.base = baseEl && baseEl.getAttribute('href');
}
HTML5History.prototype.start = function start() {
var _this = this;
this.listener = function (e) {
var url = decodeURI(location.pathname + location.search);
if (_this.root) {
url = url.replace(_this.rootRE, '');
}
_this.onChange(url, e && e.state, location.hash);
};
window.addEventListener('popstate', this.listener);
this.listener();
};
HTML5History.prototype.stop = function stop() {
window.removeEventListener('popstate', this.listener);
};
HTML5History.prototype.go = function go(path, replace, append) {
var url = this.formatPath(path, append);
if (replace) {
history.replaceState({}, '', url);
} else {
// record scroll position by replacing current state
history.replaceState({
pos: {
x: window.pageXOffset,
y: window.pageYOffset
}
}, '');
// then push new state
history.pushState({}, '', url);
}
var hashMatch = path.match(hashRE);
var hash = hashMatch && hashMatch[0];
path = url
// strip hash so it doesn't mess up params
.replace(hashRE, '')
// remove root before matching
.replace(this.rootRE, '');
this.onChange(path, null, hash);
};
HTML5History.prototype.formatPath = function formatPath(path, append) {
return path.charAt(0) === '/'
// absolute path
? this.root ? this.root + '/' + path.replace(/^\//, '') : path : _util.resolvePath(this.base || location.pathname, path, append);
};
return HTML5History;
})();
exports['default'] = HTML5History;
module.exports = exports['default'];
/***/ }
/******/ ])
});
;