diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3c3629e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/css/gamutable.css b/css/gamutable.css new file mode 100644 index 0000000..5dc17e0 --- /dev/null +++ b/css/gamutable.css @@ -0,0 +1,20 @@ +.gamutable--pagination { + display: flex; +} + +.iconeTri { + float: right; + position: relative; +} +.iconeTri .fa-sort-asc { + position: absolute; + color: #cecece; + cursor: pointer; +} +.iconeTri .fa-sort-desc { + color: #cecece; + cursor: pointer; +} +.iconeTri .active { + color: #000; +} diff --git a/fabrique_gamutable.php b/fabrique_gamutable.php deleted file mode 100644 index 47614aa..0000000 --- a/fabrique_gamutable.php +++ /dev/null @@ -1,106 +0,0 @@ - - array ( - 'version' => 7, - ), - 'paquet' => - array ( - 'prefixe' => 'gamutable', - 'nom' => 'GamuTable', - 'slogan' => '', - 'description' => 'Affichage des "table" en utilisant vuejs', - 'credits' => - array ( - 'logo' => - array ( - 'texte' => '', - 'url' => '', - ), - ), - 'version' => '1.0.0', - 'auteur' => 'tofulm', - 'auteur_lien' => 'https://gamuza.fr', - 'licence' => 'GNU/GPL', - 'categorie' => 'outil', - 'etat' => 'dev', - 'compatibilite' => '[3.2.0-dev;3.3.*]', - 'documentation' => '', - 'administrations' => '', - 'schema' => '1.0.0', - 'formulaire_config' => 'on', - 'formulaire_config_titre' => '', - 'fichiers' => - array ( - 0 => 'autorisations', - 1 => 'fonctions', - 2 => 'options', - 3 => 'pipelines', - ), - 'inserer' => - array ( - 'paquet' => '', - 'administrations' => - array ( - 'maj' => '', - 'desinstallation' => '', - 'fin' => '', - ), - 'base' => - array ( - 'tables' => - array ( - 'fin' => '', - ), - ), - ), - 'scripts' => - array ( - 'pre_copie' => '', - 'post_creation' => '', - ), - 'exemples' => '', - ), - 'objets' => - array ( - ), - 'images' => - array ( - 'paquet' => - array ( - 'logo' => - array ( - 0 => - array ( - 'extension' => 'svg', - 'contenu' => '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', - ), - ), - ), - 'objets' => - array ( - ), - ), -); diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 0000000..20dc927 --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,141 @@ +const { src, dest, series, parallel, watch } = require('gulp'); +const gulpSass = require('gulp-sass'); +const sourcemaps = require('gulp-sourcemaps'); +const postcss = require('gulp-postcss'); +const autoprefixer = require('autoprefixer'); +const cssnano = require('cssnano'); +const notify = require('gulp-notify'); +const concat = require('gulp-concat'); +const uglify = require('gulp-uglify'); +const babel = require('gulp-babel'); +const rename = require('gulp-regex-rename'); +const unuse = require('postcss-uncss'); //https://github.com/uncss/postcss-uncss + +/* + * SASS$ + */ +function sass() { + let options_unuse = { + html: 'http://starter.spip' + }; + return ( + src('css/**/*.scss') + .pipe(sourcemaps.init()) + .pipe(gulpSass({ outputStyle: 'expanded' })) + .on('error', err => notify().write(err)) + .pipe(postcss([autoprefixer()])) // autoprefixer + //.pipe(postcss([autoprefixer(), cssnano()])) // autoprefixer + minifier + //.pipe(postcss([unuse(options_unuse), autoprefixer()])) // css unuse + autoprefixer + .pipe(sourcemaps.write('.')) // initialize sourcemaps first + .pipe(dest('css')) + ); +} + +/* + * JS -> concat + babel + */ +function jsConcatMinif() { + return src(['./js/a_compresser/*.js']) + .pipe(sourcemaps.init()) + .pipe( + babel({ + presets: ['@babel/preset-env'] + }) + ) + .pipe(concat('mon_site.min.js', { newLine: ';' })) + .pipe(uglify()) + .pipe(sourcemaps.write('.')) + .pipe(dest('./js')); +} + +/* + * JS -> babel + */ +function jsBabel() { + return src(['js/*.es6.js']) + .pipe( + babel({ + presets: ['@babel/preset-env'] + }) + ) + .pipe(rename(/\.es6/, '')) + .pipe(dest('./js')); +} + +/* + * Les Watchers + */ +function watcherSass() { + watch('css/**/*.scss', { ignoreInitial: false }, sass).on('change', function() { + notify('CSS -> SCSS ==> OK').write(''); + }); +} + +function watcherJsConcatMinif() { + watch('./js/a_compresser/*.js', { ignoreInitial: false }, jsConcatMinif).on('change', function() { + notify('JS (concat) ==> OK').write(''); + }); +} + +function watcherJsBabel() { + watch('./js/*.es6.js', { ignoreInitial: false }, jsBabel).on('change', function() { + notify('JS (babel) ==> OK').write(''); + }); +} + +/* + * SVG sprite + */ +const gulpSvgSprite = require('gulp-svg-sprite'); +const config = { + shape: { + spacing: { + box: 'icon' + } + }, + mode: { + //"view": { + //"dest": ".", + //"sprite": "sprite_css_pictos.svg", + //"bust": false + //}, + + symbol: { + dest: '.', + sprite: 'sprite_symbol_pictos.svg' + } + } +}; + +function svgSprite() { + return ( + src('svg/**/*.svg') + //.pipe(plumber()) + .pipe(gulpSvgSprite(config)) + .on('error', function(error) { + console.log(error); + }) + .pipe(dest('img')) + ); +} + +/* + * SVG minifier + */ +var svgmin = require('gulp-svgmin'); +function svgMin() { + return src('svg/*.svg') + .pipe(svgmin()) + .pipe(dest('./svgmin')); +} + +/* + * Exports des fonctions + */ +module.exports = { + default: parallel(sass, jsConcatMinif, jsBabel), + sass: sass, + watch: parallel(watcherSass, watcherJsConcatMinif, watcherJsBabel), + sprite: svgSprite, + svgmin: svgMin +}; diff --git a/inclure/gamutable.html b/inclure/gamutable.html new file mode 100644 index 0000000..d390a96 --- /dev/null +++ b/inclure/gamutable.html @@ -0,0 +1,12 @@ + + +
+ +
+ + + diff --git a/js/gamutable.es6.js b/js/gamutable.es6.js new file mode 100644 index 0000000..43c20a3 --- /dev/null +++ b/js/gamutable.es6.js @@ -0,0 +1,212 @@ +jQuery(function() { + gamutable(); + //onAjaxLoad(gamutable); + function gamutable() { + $('#app').on('click', '.url_action', function(e) { + e.preventDefault(); + e.stopPropagation(); + let url = $(this).attr('href'); + $.ajax({ + url: url, + async: true + }).done(function() { + app.rechargerJson(); + }); + }); + } +}); +function recupJson(d) { + try { + return JSON.parse(d); + } catch (e) { + return []; + } +} +console.time('Chargement de VueJS AVANT Ajax'); +console.time('Chargement de VueJs APRES Ajax'); +Vue.nextTick(function() { + console.timeEnd('Chargement de VueJS AVANT Ajax'); +}); + +let monTableau = { + props: { + tparpage: { + type: Array, + default: function() { + return [10, 20, 50, 'Tous']; + } + }, + apiuri: { + type: String, + required: true + }, + objet: { + type: String + } + }, + data: function() { + return { + message: `Hello Vue ! `, + table: [], + header: [], + crayons: [], + search: '', + page: 1, + parPage: this.tparpage[0], + parPageSelect: this.tparpage[0], + pages: [], + triOrders: [], + triProps: [] + }; + }, + mounted() { + this.chargerJson(); + }, + computed: { + tableau: function() { + console.log('computed tableau'); + return this.pagination( + this.table.filter(ligne => { + if (this.search) { + if (!Object.values(ligne).every(el => el.indexOf(this.search))) { + return ligne; + } + } else { + return ligne; + } + }) + ); + } + }, + watch: { + tableau() { + this.setPages(); + }, + parPageSelect(e) { + if (!parseInt(e)) { + this.parPage = this.table.length; + } else { + this.parPage = e; + } + } + }, + methods: { + chargerJson() { + fetch(this.apiuri) + .then(response => response.json()) + .then(data => { + let config = data.shift(); + this.header = config.header; + this.crayons = config.crayons; + this.table = data; + Vue.nextTick(function() { + console.timeEnd('Chargement de VueJs APRES Ajax'); + }); + }) + .catch(error => console.log(error)); + }, + setPages() { + let nombreDePages = Math.ceil(this.table.length / this.parPage); + this.pages = []; + for (let index = 1; index <= nombreDePages; index++) { + this.pages.push(index); + } + }, + pagination(tableau) { + let page = this.page; + let parPage = this.parPage; + let from = page * parPage - parPage; + let to = page * parPage; + return tableau.slice(from, to); + }, + afficher_crayons(name, id) { + if (Object.keys(this.crayons).indexOf(name) !== -1) { + return `crayon ${this.crayons[name]}-${name}-${id}`; + } + }, + tri(col, sens) { + const i = this.triProps.indexOf(col); + if (i !== -1) { + this.triOrders[i] = sens; + } else { + this.triProps.push(col); + this.triOrders.push(sens); + } + const orderBy = (arr, props, orders) => + arr.sort((a, b) => + props.reduce((acc, prop, i) => { + if (acc === 0) { + const [p1, p2] = orders && orders[i] === 'desc' ? [b[prop], a[prop]] : [a[prop], b[prop]]; + acc = p1 > p2 ? 1 : p1 < p2 ? -1 : 0; + } + return acc; + }, 0) + ); + this.table = orderBy(this.table, this.triProps, this.triOrders); + }, + ordreActif(col, sens) { + const i = this.triProps.indexOf(col); + if (i !== -1) { + if (this.triOrders[i] === sens) { + return 'active'; + } + } + } + }, + template: ` +
+

{{ message }}

+
+
+ + +
+ + + + + + + + + + + +
+ {{head}} + + + + +
+ {{td}} +
+
+
{{table.length}} éléments
+
+ + +
+
+ +
+
+ + +
+
+
+
` +}; + +let app = new Vue({ + el: '#app', + components: { monTableau }, + methods: { + rechargerJson() { + this.$refs.montableau.chargerJson(); + } + } +}); diff --git a/js/gamutable.js b/js/gamutable.js new file mode 100644 index 0000000..d738633 --- /dev/null +++ b/js/gamutable.js @@ -0,0 +1,195 @@ +"use strict"; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + +function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +jQuery(function () { + gamutable(); //onAjaxLoad(gamutable); + + function gamutable() { + $('#app').on('click', '.url_action', function (e) { + e.preventDefault(); + e.stopPropagation(); + var url = $(this).attr('href'); + $.ajax({ + url: url, + async: true + }).done(function () { + app.rechargerJson(); + }); + }); + } +}); + +function recupJson(d) { + try { + return JSON.parse(d); + } catch (e) { + return []; + } +} + +console.time('Chargement de VueJS AVANT Ajax'); +console.time('Chargement de VueJs APRES Ajax'); +Vue.nextTick(function () { + console.timeEnd('Chargement de VueJS AVANT Ajax'); +}); +var monTableau = { + props: { + tparpage: { + type: Array, + default: function _default() { + return [10, 20, 50, 'Tous']; + } + }, + apiuri: { + type: String, + required: true + }, + objet: { + type: String + } + }, + data: function data() { + return { + message: "Hello Vue ! ", + table: [], + header: [], + crayons: [], + search: '', + page: 1, + parPage: this.tparpage[0], + parPageSelect: this.tparpage[0], + pages: [], + triOrders: [], + triProps: [] + }; + }, + mounted: function mounted() { + this.chargerJson(); + }, + computed: { + tableau: function tableau() { + var _this = this; + + console.log('computed tableau'); + return this.pagination(this.table.filter(function (ligne) { + if (_this.search) { + if (!Object.values(ligne).every(function (el) { + return el.indexOf(_this.search); + })) { + return ligne; + } + } else { + return ligne; + } + })); + } + }, + watch: { + tableau: function tableau() { + this.setPages(); + }, + parPageSelect: function parPageSelect(e) { + if (!parseInt(e)) { + this.parPage = this.table.length; + } else { + this.parPage = e; + } + } + }, + methods: { + chargerJson: function chargerJson() { + var _this2 = this; + + fetch(this.apiuri).then(function (response) { + return response.json(); + }).then(function (data) { + var config = data.shift(); + _this2.header = config.header; + _this2.crayons = config.crayons; + _this2.table = data; + Vue.nextTick(function () { + console.timeEnd('Chargement de VueJs APRES Ajax'); + }); + }).catch(function (error) { + return console.log(error); + }); + }, + setPages: function setPages() { + var nombreDePages = Math.ceil(this.table.length / this.parPage); + this.pages = []; + + for (var index = 1; index <= nombreDePages; index++) { + this.pages.push(index); + } + }, + pagination: function pagination(tableau) { + var page = this.page; + var parPage = this.parPage; + var from = page * parPage - parPage; + var to = page * parPage; + return tableau.slice(from, to); + }, + afficher_crayons: function afficher_crayons(name, id) { + if (Object.keys(this.crayons).indexOf(name) !== -1) { + return "crayon ".concat(this.crayons[name], "-").concat(name, "-").concat(id); + } + }, + tri: function tri(col, sens) { + var i = this.triProps.indexOf(col); + + if (i !== -1) { + this.triOrders[i] = sens; + } else { + this.triProps.push(col); + this.triOrders.push(sens); + } + + var orderBy = function orderBy(arr, props, orders) { + return arr.sort(function (a, b) { + return props.reduce(function (acc, prop, i) { + if (acc === 0) { + var _ref = orders && orders[i] === 'desc' ? [b[prop], a[prop]] : [a[prop], b[prop]], + _ref2 = _slicedToArray(_ref, 2), + p1 = _ref2[0], + p2 = _ref2[1]; + + acc = p1 > p2 ? 1 : p1 < p2 ? -1 : 0; + } + + return acc; + }, 0); + }); + }; + + this.table = orderBy(this.table, this.triProps, this.triOrders); + }, + ordreActif: function ordreActif(col, sens) { + var i = this.triProps.indexOf(col); + + if (i !== -1) { + if (this.triOrders[i] === sens) { + return 'active'; + } + } + } + }, + template: "\n\t
\n\t\t

{{ message }}

\n\t\t
\n\t\t\t
\n\t\t\t\t\n\t\t\t\t\n\t\t\t
\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\n\t\t\t
\n\t\t\t\t\t\t\t{{head}}\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t{{td}}\n\t\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t
{{table.length}} \xE9l\xE9ments
\n\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t
\n\t\t\t
\n\t\t
\n\t
" +}; +var app = new Vue({ + el: '#app', + components: { + monTableau: monTableau + }, + methods: { + rechargerJson: function rechargerJson() { + this.$refs.montableau.chargerJson(); + } + } +}); \ No newline at end of file diff --git a/js/vue.js b/js/vue.js new file mode 100644 index 0000000..9259645 --- /dev/null +++ b/js/vue.js @@ -0,0 +1,10834 @@ +/*! + * Vue.js v2.5.16 + * (c) 2014-2018 Evan You + * Released under the MIT License. + */ +(function(global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' + ? (module.exports = factory()) + : typeof define === 'function' && define.amd + ? define(factory) + : (global.Vue = factory()); +})(this, function() { + 'use strict'; + + /* */ + + var emptyObject = Object.freeze({}); + + // these helpers produces better vm code in JS engines due to their + // explicitness and function inlining + function isUndef(v) { + return v === undefined || v === null; + } + + function isDef(v) { + return v !== undefined && v !== null; + } + + function isTrue(v) { + return v === true; + } + + function isFalse(v) { + return v === false; + } + + /** + * Check if value is primitive + */ + function isPrimitive(value) { + return ( + typeof value === 'string' || + typeof value === 'number' || + // $flow-disable-line + typeof value === 'symbol' || + typeof value === 'boolean' + ); + } + + /** + * Quick object check - this is primarily used to tell + * Objects from primitive values when we know the value + * is a JSON-compliant type. + */ + function isObject(obj) { + return obj !== null && typeof obj === 'object'; + } + + /** + * Get the raw type string of a value e.g. [object Object] + */ + var _toString = Object.prototype.toString; + + function toRawType(value) { + return _toString.call(value).slice(8, -1); + } + + /** + * Strict object type check. Only returns true + * for plain JavaScript objects. + */ + function isPlainObject(obj) { + return _toString.call(obj) === '[object Object]'; + } + + function isRegExp(v) { + return _toString.call(v) === '[object RegExp]'; + } + + /** + * Check if val is a valid array index. + */ + function isValidArrayIndex(val) { + var n = parseFloat(String(val)); + return n >= 0 && Math.floor(n) === n && isFinite(val); + } + + /** + * Convert a value to a string that is actually rendered. + */ + function toString(val) { + return val == null ? '' : typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val); + } + + /** + * Convert a input value to a number for persistence. + * If the conversion fails, return original string. + */ + function toNumber(val) { + var n = parseFloat(val); + return isNaN(n) ? val : n; + } + + /** + * Make a map and return a function for checking if a key + * is in that map. + */ + function makeMap(str, expectsLowerCase) { + var map = Object.create(null); + var list = str.split(','); + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase + ? function(val) { + return map[val.toLowerCase()]; + } + : function(val) { + return map[val]; + }; + } + + /** + * Check if a tag is a built-in tag. + */ + var isBuiltInTag = makeMap('slot,component', true); + + /** + * Check if a attribute is a reserved attribute. + */ + var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); + + /** + * Remove an item from an array + */ + function remove(arr, item) { + if (arr.length) { + var index = arr.indexOf(item); + if (index > -1) { + return arr.splice(index, 1); + } + } + } + + /** + * Check whether the object has the property. + */ + var hasOwnProperty = Object.prototype.hasOwnProperty; + function hasOwn(obj, key) { + return hasOwnProperty.call(obj, key); + } + + /** + * Create a cached version of a pure function. + */ + function cached(fn) { + var cache = Object.create(null); + return function cachedFn(str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; + } + + /** + * Camelize a hyphen-delimited string. + */ + var camelizeRE = /-(\w)/g; + var camelize = cached(function(str) { + return str.replace(camelizeRE, function(_, c) { + return c ? c.toUpperCase() : ''; + }); + }); + + /** + * Capitalize a string. + */ + var capitalize = cached(function(str) { + return str.charAt(0).toUpperCase() + str.slice(1); + }); + + /** + * Hyphenate a camelCase string. + */ + var hyphenateRE = /\B([A-Z])/g; + var hyphenate = cached(function(str) { + return str.replace(hyphenateRE, '-$1').toLowerCase(); + }); + + /** + * Simple bind polyfill for environments that do not support it... e.g. + * PhantomJS 1.x. Technically we don't need this anymore since native bind is + * now more performant in most browsers, but removing it would be breaking for + * code that was able to run in PhantomJS 1.x, so this must be kept for + * backwards compatibility. + */ + + /* istanbul ignore next */ + function polyfillBind(fn, ctx) { + function boundFn(a) { + var l = arguments.length; + return l ? (l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a)) : fn.call(ctx); + } + + boundFn._length = fn.length; + return boundFn; + } + + function nativeBind(fn, ctx) { + return fn.bind(ctx); + } + + var bind = Function.prototype.bind ? nativeBind : polyfillBind; + + /** + * Convert an Array-like object to a real Array. + */ + function toArray(list, start) { + start = start || 0; + var i = list.length - start; + var ret = new Array(i); + while (i--) { + ret[i] = list[i + start]; + } + return ret; + } + + /** + * Mix properties into target object. + */ + function extend(to, _from) { + for (var key in _from) { + to[key] = _from[key]; + } + return to; + } + + /** + * Merge an Array of Objects into a single Object. + */ + function toObject(arr) { + var res = {}; + for (var i = 0; i < arr.length; i++) { + if (arr[i]) { + extend(res, arr[i]); + } + } + return res; + } + + /** + * Perform no operation. + * Stubbing args to make Flow happy without leaving useless transpiled code + * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/) + */ + function noop(a, b, c) {} + + /** + * Always return false. + */ + var no = function(a, b, c) { + return false; + }; + + /** + * Return same value + */ + var identity = function(_) { + return _; + }; + + /** + * Generate a static keys string from compiler modules. + */ + function genStaticKeys(modules) { + return modules + .reduce(function(keys, m) { + return keys.concat(m.staticKeys || []); + }, []) + .join(','); + } + + /** + * Check if two values are loosely equal - that is, + * if they are plain objects, do they have the same shape? + */ + function looseEqual(a, b) { + if (a === b) { + return true; + } + var isObjectA = isObject(a); + var isObjectB = isObject(b); + if (isObjectA && isObjectB) { + try { + var isArrayA = Array.isArray(a); + var isArrayB = Array.isArray(b); + if (isArrayA && isArrayB) { + return ( + a.length === b.length && + a.every(function(e, i) { + return looseEqual(e, b[i]); + }) + ); + } else if (!isArrayA && !isArrayB) { + var keysA = Object.keys(a); + var keysB = Object.keys(b); + return ( + keysA.length === keysB.length && + keysA.every(function(key) { + return looseEqual(a[key], b[key]); + }) + ); + } else { + /* istanbul ignore next */ + return false; + } + } catch (e) { + /* istanbul ignore next */ + return false; + } + } else if (!isObjectA && !isObjectB) { + return String(a) === String(b); + } else { + return false; + } + } + + function looseIndexOf(arr, val) { + for (var i = 0; i < arr.length; i++) { + if (looseEqual(arr[i], val)) { + return i; + } + } + return -1; + } + + /** + * Ensure a function is called only once. + */ + function once(fn) { + var called = false; + return function() { + if (!called) { + called = true; + fn.apply(this, arguments); + } + }; + } + + var SSR_ATTR = 'data-server-rendered'; + + var ASSET_TYPES = ['component', 'directive', 'filter']; + + var LIFECYCLE_HOOKS = [ + 'beforeCreate', + 'created', + 'beforeMount', + 'mounted', + 'beforeUpdate', + 'updated', + 'beforeDestroy', + 'destroyed', + 'activated', + 'deactivated', + 'errorCaptured' + ]; + + /* */ + + var config = { + /** + * Option merge strategies (used in core/util/options) + */ + // $flow-disable-line + optionMergeStrategies: Object.create(null), + + /** + * Whether to suppress warnings. + */ + silent: false, + + /** + * Show production mode tip message on boot? + */ + productionTip: 'development' !== 'production', + + /** + * Whether to enable devtools + */ + devtools: 'development' !== 'production', + + /** + * Whether to record perf + */ + performance: false, + + /** + * Error handler for watcher errors + */ + errorHandler: null, + + /** + * Warn handler for watcher warns + */ + warnHandler: null, + + /** + * Ignore certain custom elements + */ + ignoredElements: [], + + /** + * Custom user key aliases for v-on + */ + // $flow-disable-line + keyCodes: Object.create(null), + + /** + * Check if a tag is reserved so that it cannot be registered as a + * component. This is platform-dependent and may be overwritten. + */ + isReservedTag: no, + + /** + * Check if an attribute is reserved so that it cannot be used as a component + * prop. This is platform-dependent and may be overwritten. + */ + isReservedAttr: no, + + /** + * Check if a tag is an unknown element. + * Platform-dependent. + */ + isUnknownElement: no, + + /** + * Get the namespace of an element + */ + getTagNamespace: noop, + + /** + * Parse the real tag name for the specific platform. + */ + parsePlatformTagName: identity, + + /** + * Check if an attribute must be bound using property, e.g. value + * Platform-dependent. + */ + mustUseProp: no, + + /** + * Exposed for legacy reasons + */ + _lifecycleHooks: LIFECYCLE_HOOKS + }; + + /* */ + + /** + * Check if a string starts with $ or _ + */ + function isReserved(str) { + var c = (str + '').charCodeAt(0); + return c === 0x24 || c === 0x5f; + } + + /** + * Define a property. + */ + function def(obj, key, val, enumerable) { + Object.defineProperty(obj, key, { + value: val, + enumerable: !!enumerable, + writable: true, + configurable: true + }); + } + + /** + * Parse simple path. + */ + var bailRE = /[^\w.$]/; + function parsePath(path) { + if (bailRE.test(path)) { + return; + } + var segments = path.split('.'); + return function(obj) { + for (var i = 0; i < segments.length; i++) { + if (!obj) { + return; + } + obj = obj[segments[i]]; + } + return obj; + }; + } + + /* */ + + // can we use __proto__? + var hasProto = '__proto__' in {}; + + // Browser environment sniffing + var inBrowser = typeof window !== 'undefined'; + var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform; + var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(); + var UA = inBrowser && window.navigator.userAgent.toLowerCase(); + var isIE = UA && /msie|trident/.test(UA); + var isIE9 = UA && UA.indexOf('msie 9.0') > 0; + var isEdge = UA && UA.indexOf('edge/') > 0; + var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android'; + var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios'; + var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; + + // Firefox has a "watch" function on Object.prototype... + var nativeWatch = {}.watch; + + var supportsPassive = false; + if (inBrowser) { + try { + var opts = {}; + Object.defineProperty(opts, 'passive', { + get: function get() { + /* istanbul ignore next */ + supportsPassive = true; + } + }); // https://github.com/facebook/flow/issues/285 + window.addEventListener('test-passive', null, opts); + } catch (e) {} + } + + // this needs to be lazy-evaled because vue may be required before + // vue-server-renderer can set VUE_ENV + var _isServer; + var isServerRendering = function() { + if (_isServer === undefined) { + /* istanbul ignore if */ + if (!inBrowser && !inWeex && typeof global !== 'undefined') { + // detect presence of vue-server-renderer and avoid + // Webpack shimming the process + _isServer = global['process'].env.VUE_ENV === 'server'; + } else { + _isServer = false; + } + } + return _isServer; + }; + + // detect devtools + var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; + + /* istanbul ignore next */ + function isNative(Ctor) { + return typeof Ctor === 'function' && /native code/.test(Ctor.toString()); + } + + var hasSymbol = + typeof Symbol !== 'undefined' && + isNative(Symbol) && + typeof Reflect !== 'undefined' && + isNative(Reflect.ownKeys); + + var _Set; // $flow-disable-line + /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) { + // use native Set when available. + _Set = Set; + } else { + // a non-standard Set polyfill that only works with primitive keys. + _Set = (function() { + function Set() { + this.set = Object.create(null); + } + Set.prototype.has = function has(key) { + return this.set[key] === true; + }; + Set.prototype.add = function add(key) { + this.set[key] = true; + }; + Set.prototype.clear = function clear() { + this.set = Object.create(null); + }; + + return Set; + })(); + } + + /* */ + + var warn = noop; + var tip = noop; + var generateComponentTrace = noop; // work around flow check + var formatComponentName = noop; + + { + var hasConsole = typeof console !== 'undefined'; + var classifyRE = /(?:^|[-_])(\w)/g; + var classify = function(str) { + return str + .replace(classifyRE, function(c) { + return c.toUpperCase(); + }) + .replace(/[-_]/g, ''); + }; + + warn = function(msg, vm) { + var trace = vm ? generateComponentTrace(vm) : ''; + + if (config.warnHandler) { + config.warnHandler.call(null, msg, vm, trace); + } else if (hasConsole && !config.silent) { + console.error('[Vue warn]: ' + msg + trace); + } + }; + + tip = function(msg, vm) { + if (hasConsole && !config.silent) { + console.warn('[Vue tip]: ' + msg + (vm ? generateComponentTrace(vm) : '')); + } + }; + + formatComponentName = function(vm, includeFile) { + if (vm.$root === vm) { + return ''; + } + var options = + typeof vm === 'function' && vm.cid != null + ? vm.options + : vm._isVue + ? vm.$options || vm.constructor.options + : vm || {}; + var name = options.name || options._componentTag; + var file = options.__file; + if (!name && file) { + var match = file.match(/([^/\\]+)\.vue$/); + name = match && match[1]; + } + + return ( + (name ? '<' + classify(name) + '>' : '') + + (file && includeFile !== false ? ' at ' + file : '') + ); + }; + + var repeat = function(str, n) { + var res = ''; + while (n) { + if (n % 2 === 1) { + res += str; + } + if (n > 1) { + str += str; + } + n >>= 1; + } + return res; + }; + + generateComponentTrace = function(vm) { + if (vm._isVue && vm.$parent) { + var tree = []; + var currentRecursiveSequence = 0; + while (vm) { + if (tree.length > 0) { + var last = tree[tree.length - 1]; + if (last.constructor === vm.constructor) { + currentRecursiveSequence++; + vm = vm.$parent; + continue; + } else if (currentRecursiveSequence > 0) { + tree[tree.length - 1] = [last, currentRecursiveSequence]; + currentRecursiveSequence = 0; + } + } + tree.push(vm); + vm = vm.$parent; + } + return ( + '\n\nfound in\n\n' + + tree + .map(function(vm, i) { + return ( + '' + + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + + (Array.isArray(vm) + ? formatComponentName(vm[0]) + '... (' + vm[1] + ' recursive calls)' + : formatComponentName(vm)) + ); + }) + .join('\n') + ); + } else { + return '\n\n(found in ' + formatComponentName(vm) + ')'; + } + }; + } + + /* */ + + var uid = 0; + + /** + * A dep is an observable that can have multiple + * directives subscribing to it. + */ + var Dep = function Dep() { + this.id = uid++; + this.subs = []; + }; + + Dep.prototype.addSub = function addSub(sub) { + this.subs.push(sub); + }; + + Dep.prototype.removeSub = function removeSub(sub) { + remove(this.subs, sub); + }; + + Dep.prototype.depend = function depend() { + if (Dep.target) { + Dep.target.addDep(this); + } + }; + + Dep.prototype.notify = function notify() { + // stabilize the subscriber list first + var subs = this.subs.slice(); + for (var i = 0, l = subs.length; i < l; i++) { + subs[i].update(); + } + }; + + // the current target watcher being evaluated. + // this is globally unique because there could be only one + // watcher being evaluated at any time. + Dep.target = null; + var targetStack = []; + + function pushTarget(_target) { + if (Dep.target) { + targetStack.push(Dep.target); + } + Dep.target = _target; + } + + function popTarget() { + Dep.target = targetStack.pop(); + } + + /* */ + + var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) { + this.tag = tag; + this.data = data; + this.children = children; + this.text = text; + this.elm = elm; + this.ns = undefined; + this.context = context; + this.fnContext = undefined; + this.fnOptions = undefined; + this.fnScopeId = undefined; + this.key = data && data.key; + this.componentOptions = componentOptions; + this.componentInstance = undefined; + this.parent = undefined; + this.raw = false; + this.isStatic = false; + this.isRootInsert = true; + this.isComment = false; + this.isCloned = false; + this.isOnce = false; + this.asyncFactory = asyncFactory; + this.asyncMeta = undefined; + this.isAsyncPlaceholder = false; + }; + + var prototypeAccessors = { child: { configurable: true } }; + + // DEPRECATED: alias for componentInstance for backwards compat. + /* istanbul ignore next */ + prototypeAccessors.child.get = function() { + return this.componentInstance; + }; + + Object.defineProperties(VNode.prototype, prototypeAccessors); + + var createEmptyVNode = function(text) { + if (text === void 0) text = ''; + + var node = new VNode(); + node.text = text; + node.isComment = true; + return node; + }; + + function createTextVNode(val) { + return new VNode(undefined, undefined, undefined, String(val)); + } + + // optimized shallow clone + // used for static nodes and slot nodes because they may be reused across + // multiple renders, cloning them avoids errors when DOM manipulations rely + // on their elm reference. + function cloneVNode(vnode) { + var cloned = new VNode( + vnode.tag, + vnode.data, + vnode.children, + vnode.text, + vnode.elm, + vnode.context, + vnode.componentOptions, + vnode.asyncFactory + ); + cloned.ns = vnode.ns; + cloned.isStatic = vnode.isStatic; + cloned.key = vnode.key; + cloned.isComment = vnode.isComment; + cloned.fnContext = vnode.fnContext; + cloned.fnOptions = vnode.fnOptions; + cloned.fnScopeId = vnode.fnScopeId; + cloned.isCloned = true; + return cloned; + } + + /* + * not type checking this file because flow doesn't play well with + * dynamically accessing methods on Array prototype + */ + + var arrayProto = Array.prototype; + var arrayMethods = Object.create(arrayProto); + + var methodsToPatch = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse']; + + /** + * Intercept mutating methods and emit events + */ + methodsToPatch.forEach(function(method) { + // cache original method + var original = arrayProto[method]; + def(arrayMethods, method, function mutator() { + var args = [], + len = arguments.length; + while (len--) args[len] = arguments[len]; + + var result = original.apply(this, args); + var ob = this.__ob__; + var inserted; + switch (method) { + case 'push': + case 'unshift': + inserted = args; + break; + case 'splice': + inserted = args.slice(2); + break; + } + if (inserted) { + ob.observeArray(inserted); + } + // notify change + ob.dep.notify(); + return result; + }); + }); + + /* */ + + var arrayKeys = Object.getOwnPropertyNames(arrayMethods); + + /** + * In some cases we may want to disable observation inside a component's + * update computation. + */ + var shouldObserve = true; + + function toggleObserving(value) { + shouldObserve = value; + } + + /** + * Observer class that is attached to each observed + * object. Once attached, the observer converts the target + * object's property keys into getter/setters that + * collect dependencies and dispatch updates. + */ + var Observer = function Observer(value) { + this.value = value; + this.dep = new Dep(); + this.vmCount = 0; + def(value, '__ob__', this); + if (Array.isArray(value)) { + var augment = hasProto ? protoAugment : copyAugment; + augment(value, arrayMethods, arrayKeys); + this.observeArray(value); + } else { + this.walk(value); + } + }; + + /** + * Walk through each property and convert them into + * getter/setters. This method should only be called when + * value type is Object. + */ + Observer.prototype.walk = function walk(obj) { + var keys = Object.keys(obj); + for (var i = 0; i < keys.length; i++) { + defineReactive(obj, keys[i]); + } + }; + + /** + * Observe a list of Array items. + */ + Observer.prototype.observeArray = function observeArray(items) { + for (var i = 0, l = items.length; i < l; i++) { + observe(items[i]); + } + }; + + // helpers + + /** + * Augment an target Object or Array by intercepting + * the prototype chain using __proto__ + */ + function protoAugment(target, src, keys) { + /* eslint-disable no-proto */ + target.__proto__ = src; + /* eslint-enable no-proto */ + } + + /** + * Augment an target Object or Array by defining + * hidden properties. + */ + /* istanbul ignore next */ + function copyAugment(target, src, keys) { + for (var i = 0, l = keys.length; i < l; i++) { + var key = keys[i]; + def(target, key, src[key]); + } + } + + /** + * Attempt to create an observer instance for a value, + * returns the new observer if successfully observed, + * or the existing observer if the value already has one. + */ + function observe(value, asRootData) { + if (!isObject(value) || value instanceof VNode) { + return; + } + var ob; + if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { + ob = value.__ob__; + } else if ( + shouldObserve && + !isServerRendering() && + (Array.isArray(value) || isPlainObject(value)) && + Object.isExtensible(value) && + !value._isVue + ) { + ob = new Observer(value); + } + if (asRootData && ob) { + ob.vmCount++; + } + return ob; + } + + /** + * Define a reactive property on an Object. + */ + function defineReactive(obj, key, val, customSetter, shallow) { + var dep = new Dep(); + + var property = Object.getOwnPropertyDescriptor(obj, key); + if (property && property.configurable === false) { + return; + } + + // cater for pre-defined getter/setters + var getter = property && property.get; + if (!getter && arguments.length === 2) { + val = obj[key]; + } + var setter = property && property.set; + + var childOb = !shallow && observe(val); + Object.defineProperty(obj, key, { + enumerable: true, + configurable: true, + get: function reactiveGetter() { + var value = getter ? getter.call(obj) : val; + if (Dep.target) { + dep.depend(); + if (childOb) { + childOb.dep.depend(); + if (Array.isArray(value)) { + dependArray(value); + } + } + } + return value; + }, + set: function reactiveSetter(newVal) { + var value = getter ? getter.call(obj) : val; + /* eslint-disable no-self-compare */ + if (newVal === value || (newVal !== newVal && value !== value)) { + return; + } + /* eslint-enable no-self-compare */ + if ('development' !== 'production' && customSetter) { + customSetter(); + } + if (setter) { + setter.call(obj, newVal); + } else { + val = newVal; + } + childOb = !shallow && observe(newVal); + dep.notify(); + } + }); + } + + /** + * Set a property on an object. Adds the new property and + * triggers change notification if the property doesn't + * already exist. + */ + function set(target, key, val) { + if ('development' !== 'production' && (isUndef(target) || isPrimitive(target))) { + warn('Cannot set reactive property on undefined, null, or primitive value: ' + target); + } + if (Array.isArray(target) && isValidArrayIndex(key)) { + target.length = Math.max(target.length, key); + target.splice(key, 1, val); + return val; + } + if (key in target && !(key in Object.prototype)) { + target[key] = val; + return val; + } + var ob = target.__ob__; + if (target._isVue || (ob && ob.vmCount)) { + 'development' !== 'production' && + warn( + 'Avoid adding reactive properties to a Vue instance or its root $data ' + + 'at runtime - declare it upfront in the data option.' + ); + return val; + } + if (!ob) { + target[key] = val; + return val; + } + defineReactive(ob.value, key, val); + ob.dep.notify(); + return val; + } + + /** + * Delete a property and trigger change if necessary. + */ + function del(target, key) { + if ('development' !== 'production' && (isUndef(target) || isPrimitive(target))) { + warn('Cannot delete reactive property on undefined, null, or primitive value: ' + target); + } + if (Array.isArray(target) && isValidArrayIndex(key)) { + target.splice(key, 1); + return; + } + var ob = target.__ob__; + if (target._isVue || (ob && ob.vmCount)) { + 'development' !== 'production' && + warn('Avoid deleting properties on a Vue instance or its root $data ' + '- just set it to null.'); + return; + } + if (!hasOwn(target, key)) { + return; + } + delete target[key]; + if (!ob) { + return; + } + ob.dep.notify(); + } + + /** + * Collect dependencies on array elements when the array is touched, since + * we cannot intercept array element access like property getters. + */ + function dependArray(value) { + for (var e = void 0, i = 0, l = value.length; i < l; i++) { + e = value[i]; + e && e.__ob__ && e.__ob__.dep.depend(); + if (Array.isArray(e)) { + dependArray(e); + } + } + } + + /* */ + + /** + * Option overwriting strategies are functions that handle + * how to merge a parent option value and a child option + * value into the final value. + */ + var strats = config.optionMergeStrategies; + + /** + * Options with restrictions + */ + { + strats.el = strats.propsData = function(parent, child, vm, key) { + if (!vm) { + warn('option "' + key + '" can only be used during instance ' + 'creation with the `new` keyword.'); + } + return defaultStrat(parent, child); + }; + } + + /** + * Helper that recursively merges two data objects together. + */ + function mergeData(to, from) { + if (!from) { + return to; + } + var key, toVal, fromVal; + var keys = Object.keys(from); + for (var i = 0; i < keys.length; i++) { + key = keys[i]; + toVal = to[key]; + fromVal = from[key]; + if (!hasOwn(to, key)) { + set(to, key, fromVal); + } else if (isPlainObject(toVal) && isPlainObject(fromVal)) { + mergeData(toVal, fromVal); + } + } + return to; + } + + /** + * Data + */ + function mergeDataOrFn(parentVal, childVal, vm) { + if (!vm) { + // in a Vue.extend merge, both should be functions + if (!childVal) { + return parentVal; + } + if (!parentVal) { + return childVal; + } + // when parentVal & childVal are both present, + // we need to return a function that returns the + // merged result of both functions... no need to + // check if parentVal is a function here because + // it has to be a function to pass previous merges. + return function mergedDataFn() { + return mergeData( + typeof childVal === 'function' ? childVal.call(this, this) : childVal, + typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal + ); + }; + } else { + return function mergedInstanceDataFn() { + // instance merge + var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal; + var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal; + if (instanceData) { + return mergeData(instanceData, defaultData); + } else { + return defaultData; + } + }; + } + } + + strats.data = function(parentVal, childVal, vm) { + if (!vm) { + if (childVal && typeof childVal !== 'function') { + 'development' !== 'production' && + warn( + 'The "data" option should be a function ' + + 'that returns a per-instance value in component ' + + 'definitions.', + vm + ); + + return parentVal; + } + return mergeDataOrFn(parentVal, childVal); + } + + return mergeDataOrFn(parentVal, childVal, vm); + }; + + /** + * Hooks and props are merged as arrays. + */ + function mergeHook(parentVal, childVal) { + return childVal + ? parentVal + ? parentVal.concat(childVal) + : Array.isArray(childVal) + ? childVal + : [childVal] + : parentVal; + } + + LIFECYCLE_HOOKS.forEach(function(hook) { + strats[hook] = mergeHook; + }); + + /** + * Assets + * + * When a vm is present (instance creation), we need to do + * a three-way merge between constructor options, instance + * options and parent options. + */ + function mergeAssets(parentVal, childVal, vm, key) { + var res = Object.create(parentVal || null); + if (childVal) { + 'development' !== 'production' && assertObjectType(key, childVal, vm); + return extend(res, childVal); + } else { + return res; + } + } + + ASSET_TYPES.forEach(function(type) { + strats[type + 's'] = mergeAssets; + }); + + /** + * Watchers. + * + * Watchers hashes should not overwrite one + * another, so we merge them as arrays. + */ + strats.watch = function(parentVal, childVal, vm, key) { + // work around Firefox's Object.prototype.watch... + if (parentVal === nativeWatch) { + parentVal = undefined; + } + if (childVal === nativeWatch) { + childVal = undefined; + } + /* istanbul ignore if */ + if (!childVal) { + return Object.create(parentVal || null); + } + { + assertObjectType(key, childVal, vm); + } + if (!parentVal) { + return childVal; + } + var ret = {}; + extend(ret, parentVal); + for (var key$1 in childVal) { + var parent = ret[key$1]; + var child = childVal[key$1]; + if (parent && !Array.isArray(parent)) { + parent = [parent]; + } + ret[key$1] = parent ? parent.concat(child) : Array.isArray(child) ? child : [child]; + } + return ret; + }; + + /** + * Other object hashes. + */ + strats.props = strats.methods = strats.inject = strats.computed = function(parentVal, childVal, vm, key) { + if (childVal && 'development' !== 'production') { + assertObjectType(key, childVal, vm); + } + if (!parentVal) { + return childVal; + } + var ret = Object.create(null); + extend(ret, parentVal); + if (childVal) { + extend(ret, childVal); + } + return ret; + }; + strats.provide = mergeDataOrFn; + + /** + * Default strategy. + */ + var defaultStrat = function(parentVal, childVal) { + return childVal === undefined ? parentVal : childVal; + }; + + /** + * Validate component names + */ + function checkComponents(options) { + for (var key in options.components) { + validateComponentName(key); + } + } + + function validateComponentName(name) { + if (!/^[a-zA-Z][\w-]*$/.test(name)) { + warn( + 'Invalid component name: "' + + name + + '". Component names ' + + 'can only contain alphanumeric characters and the hyphen, ' + + 'and must start with a letter.' + ); + } + if (isBuiltInTag(name) || config.isReservedTag(name)) { + warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + name); + } + } + + /** + * Ensure all props option syntax are normalized into the + * Object-based format. + */ + function normalizeProps(options, vm) { + var props = options.props; + if (!props) { + return; + } + var res = {}; + var i, val, name; + if (Array.isArray(props)) { + i = props.length; + while (i--) { + val = props[i]; + if (typeof val === 'string') { + name = camelize(val); + res[name] = { type: null }; + } else { + warn('props must be strings when using array syntax.'); + } + } + } else if (isPlainObject(props)) { + for (var key in props) { + val = props[key]; + name = camelize(key); + res[name] = isPlainObject(val) ? val : { type: val }; + } + } else { + warn( + 'Invalid value for option "props": expected an Array or an Object, ' + + 'but got ' + + toRawType(props) + + '.', + vm + ); + } + options.props = res; + } + + /** + * Normalize all injections into Object-based format + */ + function normalizeInject(options, vm) { + var inject = options.inject; + if (!inject) { + return; + } + var normalized = (options.inject = {}); + if (Array.isArray(inject)) { + for (var i = 0; i < inject.length; i++) { + normalized[inject[i]] = { from: inject[i] }; + } + } else if (isPlainObject(inject)) { + for (var key in inject) { + var val = inject[key]; + normalized[key] = isPlainObject(val) ? extend({ from: key }, val) : { from: val }; + } + } else { + warn( + 'Invalid value for option "inject": expected an Array or an Object, ' + + 'but got ' + + toRawType(inject) + + '.', + vm + ); + } + } + + /** + * Normalize raw function directives into object format. + */ + function normalizeDirectives(options) { + var dirs = options.directives; + if (dirs) { + for (var key in dirs) { + var def = dirs[key]; + if (typeof def === 'function') { + dirs[key] = { bind: def, update: def }; + } + } + } + } + + function assertObjectType(name, value, vm) { + if (!isPlainObject(value)) { + warn( + 'Invalid value for option "' + name + '": expected an Object, ' + 'but got ' + toRawType(value) + '.', + vm + ); + } + } + + /** + * Merge two option objects into a new one. + * Core utility used in both instantiation and inheritance. + */ + function mergeOptions(parent, child, vm) { + { + checkComponents(child); + } + + if (typeof child === 'function') { + child = child.options; + } + + normalizeProps(child, vm); + normalizeInject(child, vm); + normalizeDirectives(child); + var extendsFrom = child.extends; + if (extendsFrom) { + parent = mergeOptions(parent, extendsFrom, vm); + } + if (child.mixins) { + for (var i = 0, l = child.mixins.length; i < l; i++) { + parent = mergeOptions(parent, child.mixins[i], vm); + } + } + var options = {}; + var key; + for (key in parent) { + mergeField(key); + } + for (key in child) { + if (!hasOwn(parent, key)) { + mergeField(key); + } + } + function mergeField(key) { + var strat = strats[key] || defaultStrat; + options[key] = strat(parent[key], child[key], vm, key); + } + return options; + } + + /** + * Resolve an asset. + * This function is used because child instances need access + * to assets defined in its ancestor chain. + */ + function resolveAsset(options, type, id, warnMissing) { + /* istanbul ignore if */ + if (typeof id !== 'string') { + return; + } + var assets = options[type]; + // check local registration variations first + if (hasOwn(assets, id)) { + return assets[id]; + } + var camelizedId = camelize(id); + if (hasOwn(assets, camelizedId)) { + return assets[camelizedId]; + } + var PascalCaseId = capitalize(camelizedId); + if (hasOwn(assets, PascalCaseId)) { + return assets[PascalCaseId]; + } + // fallback to prototype chain + var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; + if ('development' !== 'production' && warnMissing && !res) { + warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options); + } + return res; + } + + /* */ + + function validateProp(key, propOptions, propsData, vm) { + var prop = propOptions[key]; + var absent = !hasOwn(propsData, key); + var value = propsData[key]; + // boolean casting + var booleanIndex = getTypeIndex(Boolean, prop.type); + if (booleanIndex > -1) { + if (absent && !hasOwn(prop, 'default')) { + value = false; + } else if (value === '' || value === hyphenate(key)) { + // only cast empty string / same name to boolean if + // boolean has higher priority + var stringIndex = getTypeIndex(String, prop.type); + if (stringIndex < 0 || booleanIndex < stringIndex) { + value = true; + } + } + } + // check default value + if (value === undefined) { + value = getPropDefaultValue(vm, prop, key); + // since the default value is a fresh copy, + // make sure to observe it. + var prevShouldObserve = shouldObserve; + toggleObserving(true); + observe(value); + toggleObserving(prevShouldObserve); + } + { + assertProp(prop, key, value, vm, absent); + } + return value; + } + + /** + * Get the default value of a prop. + */ + function getPropDefaultValue(vm, prop, key) { + // no default, return undefined + if (!hasOwn(prop, 'default')) { + return undefined; + } + var def = prop.default; + // warn against non-factory defaults for Object & Array + if ('development' !== 'production' && isObject(def)) { + warn( + 'Invalid default value for prop "' + + key + + '": ' + + 'Props with type Object/Array must use a factory function ' + + 'to return the default value.', + vm + ); + } + // the raw prop value was also undefined from previous render, + // return previous default value to avoid unnecessary watcher trigger + if (vm && vm.$options.propsData && vm.$options.propsData[key] === undefined && vm._props[key] !== undefined) { + return vm._props[key]; + } + // call factory function for non-Function types + // a value is Function if its prototype is function even across different execution context + return typeof def === 'function' && getType(prop.type) !== 'Function' ? def.call(vm) : def; + } + + /** + * Assert whether a prop is valid. + */ + function assertProp(prop, name, value, vm, absent) { + if (prop.required && absent) { + warn('Missing required prop: "' + name + '"', vm); + return; + } + if (value == null && !prop.required) { + return; + } + var type = prop.type; + var valid = !type || type === true; + var expectedTypes = []; + if (type) { + if (!Array.isArray(type)) { + type = [type]; + } + for (var i = 0; i < type.length && !valid; i++) { + var assertedType = assertType(value, type[i]); + expectedTypes.push(assertedType.expectedType || ''); + valid = assertedType.valid; + } + } + if (!valid) { + warn( + 'Invalid prop: type check failed for prop "' + + name + + '".' + + ' Expected ' + + expectedTypes.map(capitalize).join(', ') + + ', got ' + + toRawType(value) + + '.', + vm + ); + return; + } + var validator = prop.validator; + if (validator) { + if (!validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm); + } + } + } + + var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/; + + function assertType(value, type) { + var valid; + var expectedType = getType(type); + if (simpleCheckRE.test(expectedType)) { + var t = typeof value; + valid = t === expectedType.toLowerCase(); + // for primitive wrapper objects + if (!valid && t === 'object') { + valid = value instanceof type; + } + } else if (expectedType === 'Object') { + valid = isPlainObject(value); + } else if (expectedType === 'Array') { + valid = Array.isArray(value); + } else { + valid = value instanceof type; + } + return { + valid: valid, + expectedType: expectedType + }; + } + + /** + * Use function string name to check built-in types, + * because a simple equality check will fail when running + * across different vms / iframes. + */ + function getType(fn) { + var match = fn && fn.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ''; + } + + function isSameType(a, b) { + return getType(a) === getType(b); + } + + function getTypeIndex(type, expectedTypes) { + if (!Array.isArray(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + for (var i = 0, len = expectedTypes.length; i < len; i++) { + if (isSameType(expectedTypes[i], type)) { + return i; + } + } + return -1; + } + + /* */ + + function handleError(err, vm, info) { + if (vm) { + var cur = vm; + while ((cur = cur.$parent)) { + var hooks = cur.$options.errorCaptured; + if (hooks) { + for (var i = 0; i < hooks.length; i++) { + try { + var capture = hooks[i].call(cur, err, vm, info) === false; + if (capture) { + return; + } + } catch (e) { + globalHandleError(e, cur, 'errorCaptured hook'); + } + } + } + } + } + globalHandleError(err, vm, info); + } + + function globalHandleError(err, vm, info) { + if (config.errorHandler) { + try { + return config.errorHandler.call(null, err, vm, info); + } catch (e) { + logError(e, null, 'config.errorHandler'); + } + } + logError(err, vm, info); + } + + function logError(err, vm, info) { + { + warn('Error in ' + info + ': "' + err.toString() + '"', vm); + } + /* istanbul ignore else */ + if ((inBrowser || inWeex) && typeof console !== 'undefined') { + console.error(err); + } else { + throw err; + } + } + + /* */ + /* globals MessageChannel */ + + var callbacks = []; + var pending = false; + + function flushCallbacks() { + pending = false; + var copies = callbacks.slice(0); + callbacks.length = 0; + for (var i = 0; i < copies.length; i++) { + copies[i](); + } + } + + // Here we have async deferring wrappers using both microtasks and (macro) tasks. + // In < 2.4 we used microtasks everywhere, but there are some scenarios where + // microtasks have too high a priority and fire in between supposedly + // sequential events (e.g. #4521, #6690) or even between bubbling of the same + // event (#6566). However, using (macro) tasks everywhere also has subtle problems + // when state is changed right before repaint (e.g. #6813, out-in transitions). + // Here we use microtask by default, but expose a way to force (macro) task when + // needed (e.g. in event handlers attached by v-on). + var microTimerFunc; + var macroTimerFunc; + var useMacroTask = false; + + // Determine (macro) task defer implementation. + // Technically setImmediate should be the ideal choice, but it's only available + // in IE. The only polyfill that consistently queues the callback after all DOM + // events triggered in the same loop is by using MessageChannel. + /* istanbul ignore if */ + if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { + macroTimerFunc = function() { + setImmediate(flushCallbacks); + }; + } else if ( + typeof MessageChannel !== 'undefined' && + (isNative(MessageChannel) || + // PhantomJS + MessageChannel.toString() === '[object MessageChannelConstructor]') + ) { + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = flushCallbacks; + macroTimerFunc = function() { + port.postMessage(1); + }; + } else { + /* istanbul ignore next */ + macroTimerFunc = function() { + setTimeout(flushCallbacks, 0); + }; + } + + // Determine microtask defer implementation. + /* istanbul ignore next, $flow-disable-line */ + if (typeof Promise !== 'undefined' && isNative(Promise)) { + var p = Promise.resolve(); + microTimerFunc = function() { + p.then(flushCallbacks); + // in problematic UIWebViews, Promise.then doesn't completely break, but + // it can get stuck in a weird state where callbacks are pushed into the + // microtask queue but the queue isn't being flushed, until the browser + // needs to do some other work, e.g. handle a timer. Therefore we can + // "force" the microtask queue to be flushed by adding an empty timer. + if (isIOS) { + setTimeout(noop); + } + }; + } else { + // fallback to macro + microTimerFunc = macroTimerFunc; + } + + /** + * Wrap a function so that if any code inside triggers state change, + * the changes are queued using a (macro) task instead of a microtask. + */ + function withMacroTask(fn) { + return ( + fn._withTask || + (fn._withTask = function() { + useMacroTask = true; + var res = fn.apply(null, arguments); + useMacroTask = false; + return res; + }) + ); + } + + function nextTick(cb, ctx) { + var _resolve; + callbacks.push(function() { + if (cb) { + try { + cb.call(ctx); + } catch (e) { + handleError(e, ctx, 'nextTick'); + } + } else if (_resolve) { + _resolve(ctx); + } + }); + if (!pending) { + pending = true; + if (useMacroTask) { + macroTimerFunc(); + } else { + microTimerFunc(); + } + } + // $flow-disable-line + if (!cb && typeof Promise !== 'undefined') { + return new Promise(function(resolve) { + _resolve = resolve; + }); + } + } + + /* */ + + var mark; + var measure; + + { + var perf = inBrowser && window.performance; + /* istanbul ignore if */ + if (perf && perf.mark && perf.measure && perf.clearMarks && perf.clearMeasures) { + mark = function(tag) { + return perf.mark(tag); + }; + measure = function(name, startTag, endTag) { + perf.measure(name, startTag, endTag); + perf.clearMarks(startTag); + perf.clearMarks(endTag); + perf.clearMeasures(name); + }; + } + } + + /* not type checking this file because flow doesn't play well with Proxy */ + + var initProxy; + + { + var allowedGlobals = makeMap( + 'Infinity,undefined,NaN,isFinite,isNaN,' + + 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + + 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + + 'require' // for Webpack/Browserify + ); + + var warnNonPresent = function(target, key) { + warn( + 'Property or method "' + + key + + '" is not defined on the instance but ' + + 'referenced during render. Make sure that this property is reactive, ' + + 'either in the data option, or for class-based components, by ' + + 'initializing the property. ' + + 'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', + target + ); + }; + + var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy); + + if (hasProxy) { + var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); + config.keyCodes = new Proxy(config.keyCodes, { + set: function set(target, key, value) { + if (isBuiltInModifier(key)) { + warn('Avoid overwriting built-in modifier in config.keyCodes: .' + key); + return false; + } else { + target[key] = value; + return true; + } + } + }); + } + + var hasHandler = { + has: function has(target, key) { + var has = key in target; + var isAllowed = allowedGlobals(key) || key.charAt(0) === '_'; + if (!has && !isAllowed) { + warnNonPresent(target, key); + } + return has || !isAllowed; + } + }; + + var getHandler = { + get: function get(target, key) { + if (typeof key === 'string' && !(key in target)) { + warnNonPresent(target, key); + } + return target[key]; + } + }; + + initProxy = function initProxy(vm) { + if (hasProxy) { + // determine which proxy handler to use + var options = vm.$options; + var handlers = options.render && options.render._withStripped ? getHandler : hasHandler; + vm._renderProxy = new Proxy(vm, handlers); + } else { + vm._renderProxy = vm; + } + }; + } + + /* */ + + var seenObjects = new _Set(); + + /** + * Recursively traverse an object to evoke all converted + * getters, so that every nested property inside the object + * is collected as a "deep" dependency. + */ + function traverse(val) { + _traverse(val, seenObjects); + seenObjects.clear(); + } + + function _traverse(val, seen) { + var i, keys; + var isA = Array.isArray(val); + if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) { + return; + } + if (val.__ob__) { + var depId = val.__ob__.dep.id; + if (seen.has(depId)) { + return; + } + seen.add(depId); + } + if (isA) { + i = val.length; + while (i--) { + _traverse(val[i], seen); + } + } else { + keys = Object.keys(val); + i = keys.length; + while (i--) { + _traverse(val[keys[i]], seen); + } + } + } + + /* */ + + var normalizeEvent = cached(function(name) { + var passive = name.charAt(0) === '&'; + name = passive ? name.slice(1) : name; + var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first + name = once$$1 ? name.slice(1) : name; + var capture = name.charAt(0) === '!'; + name = capture ? name.slice(1) : name; + return { + name: name, + once: once$$1, + capture: capture, + passive: passive + }; + }); + + function createFnInvoker(fns) { + function invoker() { + var arguments$1 = arguments; + + var fns = invoker.fns; + if (Array.isArray(fns)) { + var cloned = fns.slice(); + for (var i = 0; i < cloned.length; i++) { + cloned[i].apply(null, arguments$1); + } + } else { + // return handler return value for single handlers + return fns.apply(null, arguments); + } + } + invoker.fns = fns; + return invoker; + } + + function updateListeners(on, oldOn, add, remove$$1, vm) { + var name, def, cur, old, event; + for (name in on) { + def = cur = on[name]; + old = oldOn[name]; + event = normalizeEvent(name); + /* istanbul ignore if */ + if (isUndef(cur)) { + 'development' !== 'production' && + warn('Invalid handler for event "' + event.name + '": got ' + String(cur), vm); + } else if (isUndef(old)) { + if (isUndef(cur.fns)) { + cur = on[name] = createFnInvoker(cur); + } + add(event.name, cur, event.once, event.capture, event.passive, event.params); + } else if (cur !== old) { + old.fns = cur; + on[name] = old; + } + } + for (name in oldOn) { + if (isUndef(on[name])) { + event = normalizeEvent(name); + remove$$1(event.name, oldOn[name], event.capture); + } + } + } + + /* */ + + function mergeVNodeHook(def, hookKey, hook) { + if (def instanceof VNode) { + def = def.data.hook || (def.data.hook = {}); + } + var invoker; + var oldHook = def[hookKey]; + + function wrappedHook() { + hook.apply(this, arguments); + // important: remove merged hook to ensure it's called only once + // and prevent memory leak + remove(invoker.fns, wrappedHook); + } + + if (isUndef(oldHook)) { + // no existing hook + invoker = createFnInvoker([wrappedHook]); + } else { + /* istanbul ignore if */ + if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { + // already a merged invoker + invoker = oldHook; + invoker.fns.push(wrappedHook); + } else { + // existing plain hook + invoker = createFnInvoker([oldHook, wrappedHook]); + } + } + + invoker.merged = true; + def[hookKey] = invoker; + } + + /* */ + + function extractPropsFromVNodeData(data, Ctor, tag) { + // we are only extracting raw values here. + // validation and default values are handled in the child + // component itself. + var propOptions = Ctor.options.props; + if (isUndef(propOptions)) { + return; + } + var res = {}; + var attrs = data.attrs; + var props = data.props; + if (isDef(attrs) || isDef(props)) { + for (var key in propOptions) { + var altKey = hyphenate(key); + { + var keyInLowerCase = key.toLowerCase(); + if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) { + tip( + 'Prop "' + + keyInLowerCase + + '" is passed to component ' + + formatComponentName(tag || Ctor) + + ', but the declared prop name is' + + ' "' + + key + + '". ' + + 'Note that HTML attributes are case-insensitive and camelCased ' + + 'props need to use their kebab-case equivalents when using in-DOM ' + + 'templates. You should probably use "' + + altKey + + '" instead of "' + + key + + '".' + ); + } + } + checkProp(res, props, key, altKey, true) || checkProp(res, attrs, key, altKey, false); + } + } + return res; + } + + function checkProp(res, hash, key, altKey, preserve) { + if (isDef(hash)) { + if (hasOwn(hash, key)) { + res[key] = hash[key]; + if (!preserve) { + delete hash[key]; + } + return true; + } else if (hasOwn(hash, altKey)) { + res[key] = hash[altKey]; + if (!preserve) { + delete hash[altKey]; + } + return true; + } + } + return false; + } + + /* */ + + // The template compiler attempts to minimize the need for normalization by + // statically analyzing the template at compile time. + // + // For plain HTML markup, normalization can be completely skipped because the + // generated render function is guaranteed to return Array. There are + // two cases where extra normalization is needed: + + // 1. When the children contains components - because a functional component + // may return an Array instead of a single root. In this case, just a simple + // normalization is needed - if any child is an Array, we flatten the whole + // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep + // because functional components already normalize their own children. + function simpleNormalizeChildren(children) { + for (var i = 0; i < children.length; i++) { + if (Array.isArray(children[i])) { + return Array.prototype.concat.apply([], children); + } + } + return children; + } + + // 2. When the children contains constructs that always generated nested Arrays, + // e.g.