From 949715b028beaf7effeb22fed6c710b36bd57a7d Mon Sep 17 00:00:00 2001 From: Joas Schilling Date: Thu, 19 Oct 2017 23:08:43 +0200 Subject: [PATCH 1/8] Vue Signed-off-by: Joas Schilling --- css/styles.css | 13 + img/notifications-dark.svg | 4 + js/app.js | 473 +- js/components/action.js | 53 + js/components/notification.js | 198 + js/components/root.js | 96 + js/merged.json | 4 +- js/notification.js | 136 - js/vue.js | 10517 ++++++++++++++++++++++++++++++++ js/vue.min.js | 6 + lib/AppInfo/Application.php | 7 + 11 files changed, 10935 insertions(+), 572 deletions(-) create mode 100644 img/notifications-dark.svg create mode 100644 js/components/action.js create mode 100644 js/components/notification.js create mode 100644 js/components/root.js delete mode 100644 js/notification.js create mode 100644 js/vue.js create mode 100644 js/vue.min.js diff --git a/css/styles.css b/css/styles.css index 9dcd7d5f1..c93daf220 100644 --- a/css/styles.css +++ b/css/styles.css @@ -49,6 +49,19 @@ img.notification-icon { padding: 14px; } +.notification:hover > .notification-delete { + display: block !important; + position: absolute; + top: 7px; + right: 12px; + opacity: 0.3; +} + +.notification-delete:hover { + opacity: 0.8 !important; + cursor: pointer; +} + .notification-delete:hover, .notification-delete .icon-close, .notifications-button img { diff --git a/img/notifications-dark.svg b/img/notifications-dark.svg new file mode 100644 index 000000000..1bc88f4c3 --- /dev/null +++ b/img/notifications-dark.svg @@ -0,0 +1,4 @@ + + + + diff --git a/js/app.js b/js/app.js index 99908a4d2..e1f97cf87 100644 --- a/js/app.js +++ b/js/app.js @@ -9,435 +9,42 @@ * later. See the COPYING file. */ -(function() { +(function(OC, OCA, $, _) { + OCA.Notifications = OCA.Notifications || {}; - if (!OCA.Notifications) { - OCA.Notifications = {}; - } + OCA.Notifications.App = { - OCA.Notifications = { /** @type {number} */ pollInterval: 30000, // milliseconds + /** @type {number|null} */ interval: null, - /** @type {OCA.Notifications.Notification[]|{}} */ - notifications: {}, - - /** @type {Object} */ - $button: null, - /** @type {Object} */ - $container: null, - /** @type {Object} */ - $notifications: null, - - /** @type {Function} */ - notificationTemplate: null, - - /** @type {string} */ - _containerTemplate: '' + - '', - - /** @type {string} */ - _notificationTemplate: '' + - '
' + - '
' + - ' {{relativeDate}}' + - '
' + - ' ' + - '
' + - '
' + - ' {{#if link}}' + - ' ' + - ' {{#if icon}}{{/if}}' + - ' {{{subject}}}' + - ' ' + - ' {{else}}' + - '
' + - ' {{#if icon}}{{/if}}' + - ' {{{subject}}}' + - '
' + - ' {{/if}}' + - ' {{#if message}}
{{{message}}}
{{/if}}' + - ' ' + - ' {{#if actions}}
' + - ' {{#each actions}}' + - ' ' + - ' {{/each}}' + - '
{{/if}}' + - '
', + /** @type {Vue|null} */ + vm: null, /** * Initialise the app */ initialise: function() { - // Setup elements - var compiledTemplate = Handlebars.compile(this._containerTemplate); - this.notificationTemplate = Handlebars.compile(this._notificationTemplate); - this.$notifications = $(compiledTemplate()); - this.$button = this.$notifications.find('.notifications-button'); - this.$container = this.$notifications.find('.notification-container'); // Add to the UI - $('form.searchbox').after(this.$notifications); - - // Initial call to the notification endpoint - this.initialFetch(); + $('form.searchbox').after($('
').attr('id', 'notifications')); - // Bind the button click event - OC.registerMenu(this.$button, this.$container); - this.$button.on('click', _.bind(this._onNotificationsButtonClick, this)); + // Setup Vue + this.vm = new Vue(OCA.Notifications.Components.Root); - this.$container.on('click', '.action-button', _.bind(this._onClickAction, this)); - this.$container.on('click', '.notification-delete', _.bind(this._onClickDismissNotification, this)); + // Initial call to the notification endpoint + this._fetch(); // Setup the background checker - this.interval = setInterval(_.bind(this.backgroundFetch, this), this.pollInterval); - }, - - /** - * Handles the notification dismiss click event - * @param {Event} event - */ - _onClickDismissNotification: function(event) { - event.preventDefault(); - var self = this, - $target = $(event.target), - $notification = $target.closest('.notification'), - id = $notification.attr('data-id'); - - $notification.fadeOut(OC.menuSpeed); - - $.ajax({ - url: OC.linkToOCS('apps/notifications/api/v2', 2) + 'notifications/' + id, - type: 'DELETE', - beforeSend: function (request) { - request.setRequestHeader('Accept', 'application/json'); - }, - success: function() { - self._removeNotification(id); - }, - error: function() { - $notification.fadeIn(OC.menuSpeed); - OC.Notification.showTemporary('Failed to perform action'); - } - }); - }, - - /** - * Handles the notification action click event - * @param {Event} event - */ - _onClickAction: function(event) { - event.preventDefault(); - var self = this; - var $target = $(event.target); - var $notification = $target.closest('.notification'); - var actionType = $target.attr('data-type') || 'GET'; - var actionUrl = $target.attr('data-href'); - - $notification.fadeOut(OC.menuSpeed); - - $.ajax({ - url: actionUrl, - type: actionType, - success: function(data) { - $('body').trigger(new $.Event('OCA.Notification.Action', { - notification: self.notifications[$notification.attr('data-id')], - action: { - url: actionUrl, - type: actionType - } - })); - self._removeNotification($notification.attr('data-id')); - }, - error: function() { - $notification.fadeIn(OC.menuSpeed); - OC.Notification.showTemporary('Failed to perform action'); - } - }); - }, - - /** - * Remove a notification from the collection and the UI - * @param {Number} id - */ - _removeNotification: function(id) { - var $notification = this.notifications[id].getElement(); - delete this.notifications[id]; - - $notification.remove(); - if (this.numNotifications() === 0) { - this._onHaveNoNotifications(); - } - }, - - /** - * Handles the notification button click event - */ - _onNotificationsButtonClick: function() { - // Show a popup - OC.showMenu(null, this.$container); - }, - - /** - * Initial fetch handler - */ - initialFetch: function() { - var self = this; - - this._fetch( - function(data) { - // Fill Array - _.each(data, function(notification) { - var n = new self.Notification(notification); - self.notifications[n.getId()] = n; - self._addToUI(n); - }); - - // Check if we have any, and notify the UI - if (self.numNotifications() !== 0) { - self._onHaveNotifications(); - } else { - self._onHaveNoNotifications(); - } - }, - _.bind(self._onFetchError, self) - ); - }, - - /** - * Background fetch handler - */ - backgroundFetch: function() { - var self = this; - - this._fetch( - function(data) { - var inJson = [], - oldNum = self.numNotifications(), - resort = false; - - _.each(data, function(notification) { - var n = new self.Notification(notification); - inJson.push(n.getId()); - if (!self.getNotification(n.getId())) { - // New notification! - self._onNewNotification(n); - resort = true; - } - }); - - if (resort) { - self.$container.find('.notification').sort(function (prev, next) { - return parseInt(next.dataset.timestamp) - parseInt(prev.dataset.timestamp); - }).each(function() { - $(self.$container.find('.notification-wrapper')).append(this); - }); - } - - _.each(self.getNotifications(), function(n) { - if (inJson.indexOf(n.getId()) === -1) { - // Not in JSON, remove from UI - self._onRemoveNotification(n); - } - }); - - // Now check if we suddenly have notifs, or now none - if (oldNum === 0 && self.numNotifications() !== 0) { - // We now have some! - self._onHaveNotifications(); - } else if (oldNum !== 0 && self.numNotifications() === 0) { - // Now we have none - self._onHaveNoNotifications(); - } - }, - _.bind(self._onFetchError, self) - ); - }, - - /** - * Handles errors when requesting the notifications - * @param {XMLHttpRequest} xhr - */ - _onFetchError: function(xhr) { - if (xhr.status === 503) { - // 503 - Maintenance mode - console.debug('Shutting down notifications: instance is in maintenance mode.'); - } else if (xhr.status === 404) { - // 404 - App disabled - console.debug('Shutting down notifications: app is disabled.'); - } else { - console.error('Shutting down notifications: [' + xhr.status + '] ' + xhr.statusText); - } - this._shutDownNotifications(); - }, - - /** - * Handles removing the Notification from the UI when no longer in JSON - * @param {OCA.Notifications.Notification} notification - */ - _onRemoveNotification: function(notification) { - notification.getElement().remove(); - delete this.notifications[notification.getId()]; - }, - - /** - * Handle new notification received - * @param {OCA.Notifications.Notification} notification - */ - _onNewNotification: function(notification) { - var self = this; - // Add it to the array - this.notifications[notification.getId()] = notification; - // Add to the UI - this._addToUI(notification); - - // Trigger browsers web notification - // https://github.com/owncloud/notifications/issues/1 - if ("Notification" in window) { - if (Notification.permission === "granted") { - // If it's okay let's create a notification - this._createWebNotification(notification); - } - - // Otherwise, we need to ask the user for permission - else if (Notification.permission !== 'denied') { - Notification.requestPermission(function (permission) { - // If the user accepts, let's create a notification - if (permission === "granted") { - self._createWebNotification(notification); - } - }); - } - } - }, - - /** - * Create a browser notification - * - * @see https://developer.mozilla.org/en/docs/Web/API/notification - * @param {OCA.Notifications.Notification} notification - */ - _createWebNotification: function (notification) { - var n = new Notification(notification.getPlainSubject(), { - title: notification.getPlainSubject(), - lang: OC.getLocale(), - body: notification.getMessage(), - icon: notification.getIcon(), - tag: notification.getId() - }); - - if (notification.getLink()) { - n.onclick = function(event) { - event.preventDefault(); - window.location.href = notification.getLink(); - } - } - - setTimeout(n.close.bind(n), 5000); - }, - - /** - * The app was disabled or has no notifiers, so we can stop polling - * And hide the UI as well - */ - _shutDownNotifications: function() { - window.clearInterval(this.interval); - this.$notifications.addClass('hidden'); - }, - - /** - * Adds the notification to the UI - * @param {OCA.Notifications.Notification} notification - */ - _addToUI: function(notification) { - var $element = $(notification.renderElement(this.notificationTemplate)); - - $element.find('.avatar').each(function() { - var element = $(this); - if (element.data('user-display-name')) { - element.avatar(element.data('user'), 21, undefined, false, undefined, element.data('user-display-name')); - } else { - element.avatar(element.data('user'), 21); - } - }); - - $element.find('.avatar-name-wrapper').each(function() { - var element = $(this); - var avatar = element.find('.avatar'); - var label = element.find('strong'); - - $.merge(avatar, label).contactsMenu(element.data('user'), 0, element); - }); - - $element.find('.has-tooltip').tooltip({ - container: this.$container.find('.notification-wrapper'), - placement: 'bottom' - }); - - $element.find('.notification-message').on('click', function() { - var $fullMessage = $(this).parent().find('.notification-full-message'); - $(this).addClass('hidden'); - $fullMessage.removeClass('hidden'); - }); - - this.$container.find('.notification-wrapper').append($element); - }, - - /** - * Handle event when we have notifications (and didnt before) - */ - _onHaveNotifications: function() { - // Add the button, title, etc - var icon; - if (OCA.Theming && OCA.Theming.inverted) { - icon = 'notifications-new-dark'; - } else { - icon = 'notifications-new'; - } - this.$button.addClass('hasNotifications'); - this.$button.find('img').attr('src', OC.imagePath('notifications', icon)) - .animate({opacity: 0.6}, 600) - .animate({opacity: 1}, 600) - .animate({opacity: 0.6}, 600) - .animate({opacity: 1}, 600); - this.$container.find('.emptycontent').addClass('hidden'); - - this.$notifications.removeClass('hidden'); - }, - - /** - * Handle when all dismissed - */ - _onHaveNoNotifications: function() { - // Remove the border - this.$button.removeClass('hasNotifications'); - this.$container.find('.emptycontent').removeClass('hidden'); - this.$button.find('img').attr('src', OC.imagePath('notifications', 'notifications')); - - this.$notifications.addClass('hidden'); + this.interval = setInterval(this._backgroundFetch.bind(this), this.pollInterval); }, /** * Performs the AJAX request to retrieve the notifications - * @param {Function} success - * @param {Function} failure */ - _fetch: function(success, failure) { - var self = this; + _fetch: function() { var request = $.ajax({ url: OC.linkToOCS('apps/notifications/api/v2', 2) + 'notifications', type: 'GET', @@ -449,48 +56,44 @@ request.done(function(data, statusText, xhr) { if (xhr.status === 204) { // 204 No Content - Intercept when no notifiers are there. - self._shutDownNotifications(); + this._shutDownNotifications(); } else if (!_.isUndefined(data) && !_.isUndefined(data.ocs) && !_.isUndefined(data.ocs.data) && _.isArray(data.ocs.data)) { - success(data.ocs.data, statusText, xhr); + this.vm.notifications = data.ocs.data; } else { console.debug("data.ocs.data is undefined or not an array"); } - }); - request.fail(failure); - }, + }.bind(this)); + request.fail(function(xhr) { + if (xhr.status === 503) { + // 503 - Maintenance mode + console.debug('Shutting down notifications: instance is in maintenance mode.'); + } else if (xhr.status === 404) { + // 404 - App disabled + console.debug('Shutting down notifications: app is disabled.'); + } else { + console.error('Shutting down notifications: [' + xhr.status + '] ' + xhr.statusText); + } - /** - * Retrieves a notification object by id - * @param {int} id - * @return {OCA.Notifications.Notification|boolean} - */ - getNotification: function(id) { - if (!_.isUndefined(this.notifications[id])) { - return this.notifications[id]; - } else { - return false; - } + this._shutDownNotifications(); + }.bind(this)); }, - /** - * Returns all notification objects - * @return {OCA.Notifications.Notification[]} - */ - getNotifications: function() { - return this.notifications; + _backgroundFetch: function() { + this.vm.backgroundFetching = true; + this._fetch(); }, /** - * Returns how many notifications in the UI - * @return {int} + * The app was disabled or has no notifiers, so we can stop polling + * And hide the UI as well */ - numNotifications: function() { - return _.keys(this.notifications).length; + _shutDownNotifications: function() { + window.clearInterval(this.interval); + this.vm.shutdown = true; } - }; -})(); +})(OC, OCA, $, _); $(document).ready(function () { - OCA.Notifications.initialise(); + OCA.Notifications.App.initialise(); }); diff --git a/js/components/action.js b/js/components/action.js new file mode 100644 index 000000000..a4cd09453 --- /dev/null +++ b/js/components/action.js @@ -0,0 +1,53 @@ +/** + * @copyright (c) 2017 Joas Schilling + * + * @author Joas Schilling + * + * This file is licensed under the Affero General Public License version 3 or + * later. See the COPYING file. + */ + +(function(OC, OCA, $) { + OCA.Notifications = OCA.Notifications || {}; + OCA.Notifications.Components = OCA.Notifications.Components || {}; + + OCA.Notifications.Components.Action = { + /** @type {string} */ + template: '' + + '{{ label }}', + + props: [ + 'label', + 'link', + 'type', + 'primary' + ], + + methods: { + onClickActionButton: function () { + $.ajax({ + url: this.link, + type: this.type || 'GET', + success: function () { + this.$parent._$el.fadeOut(OC.menuSpeed); + this.$parent.$emit('remove'); + // $('body').trigger(new $.Event('OCA.Notification.Action', { + // notification: this.$parent, + // action: { + // url: this.link, + // type: this.type || 'GET' + // } + // })); + }.bind(this), + error: function () { + OC.Notification.showTemporary('Failed to perform action'); // FIXME translation + } + }); + } + } + }; +})(OC, OCA, $); diff --git a/js/components/notification.js b/js/components/notification.js new file mode 100644 index 000000000..fc4ff0bec --- /dev/null +++ b/js/components/notification.js @@ -0,0 +1,198 @@ +/** + * @copyright (c) 2017 Joas Schilling + * + * @author Joas Schilling + * + * This file is licensed under the Affero General Public License version 3 or + * later. See the COPYING file. + */ + +(function(OC, OCA, $) { + OCA.Notifications = OCA.Notifications || {}; + OCA.Notifications.Components = OCA.Notifications.Components || {}; + + OCA.Notifications.Components.Notification = { + template: '' + + '
' + + '
' + + ' {{relativeDate}}' + + '
' + + ' ' + + '
' + + '
' + + ' ' + + ' ' + + ' ' + + ' ' + + '
' + + ' ' + + ' ' + + '
' + + '
' + + ' ' + + '
' + + ' ' + + '
' + + '
', + + props: [ + 'notification_id', + 'datetime', + 'app', + 'icon', + 'link', + 'user', + 'message', + 'messageRich', + 'messageRichParameters', + 'subject', + 'subjectRich', + 'subjectRichParameters', + 'object_type', + 'object_id', + 'actions' + ], + + _$el: null, + + computed: { + timestamp: function() { + return moment(this.datetime).format('X') * 1000; + }, + absoluteDate: function() { + return OC.Util.formatDate(this.timestamp); + }, + relativeDate: function() { + return OC.Util.relativeModifiedDate(this.timestamp); + }, + useLink: function() { + return this.link && this.renderedSubject.indexOf(' 200) { + var spacePosition = message.indexOf(' ', 180); + if (spacePosition !== -1 && spacePosition <= 200) { + message = message.substring(0, spacePosition); + } else { + message = message.substring(0, 200); + } + message += '…'; + } + + return message.replace(new RegExp("\n", 'g'), ' '); + } + }, + + methods: { + onClickFullMessage: function() { + this._$el.find('.notification-message').addClass('hidden'); + this._$el.find('.notification-full-message').removeClass('hidden'); + }, + + onDismissNotification: function() { + $.ajax({ + url: OC.linkToOCS('apps/notifications/api/v2', 2) + 'notifications/' + this.notification_id, + type: 'DELETE', + success: function () { + this._$el.fadeOut(OC.menuSpeed); + this.$emit('remove'); + }.bind(this), + error: function () { + OC.Notification.showTemporary('Failed to perform action'); // FIXME translation + } + }); + }, + + /** + * Check if we do web notifications + */ + _triggerWebNotification: function () { + // Trigger browsers web notification + if ("Notification" in window) { + if (Notification.permission === "granted") { + // If it's okay let's create a notification + this._createWebNotification(); + } + + // Otherwise, we need to ask the user for permission + else if (Notification.permission !== 'denied') { + Notification.requestPermission(function (permission) { + // If the user accepts, let's create a notification + if (permission === "granted") { + this._createWebNotification(); + } + }.bind(this)); + } + } + }, + + /** + * Create a browser notification + * @see https://developer.mozilla.org/en/docs/Web/API/notification + */ + _createWebNotification: function () { + var n = new Notification(this.subject, { + title: this.subject, + lang: OC.getLocale(), + body: this.message, + icon: this.icon, + tag: this.notification_id + }); + + if (this.link) { + n.onclick = function(event) { + event.preventDefault(); + window.location.href = this.link; + }.bind(this); + } + + setTimeout(n.close.bind(n), 5000); + } + }, + + mounted: function () { + this._$el = $(this.$el); + + this._$el.find('.avatar').each(function() { + var element = $(this); + if (element.data('user-display-name')) { + element.avatar(element.data('user'), 21, undefined, false, undefined, element.data('user-display-name')); + } else { + element.avatar(element.data('user'), 21); + } + }); + + this._$el.find('.avatar-name-wrapper').each(function() { + var element = $(this); + var avatar = element.find('.avatar'); + var label = element.find('strong'); + + $.merge(avatar, label).contactsMenu(element.data('user'), 0, element); + }); + + this._$el.find('.has-tooltip').tooltip({ + //container: this.$container.find('.notification-wrapper'), + placement: 'bottom' + }); + + if (this.$parent.backgroundFetching) { + this._triggerWebNotification(); + } + }, + + components: { + 'action': OCA.Notifications.Components.Action + } + }; +})(OC, OCA, $); diff --git a/js/components/root.js b/js/components/root.js new file mode 100644 index 000000000..08d087cc1 --- /dev/null +++ b/js/components/root.js @@ -0,0 +1,96 @@ +/** + * @copyright (c) 2017 Joas Schilling + * + * @author Joas Schilling + * + * This file is licensed under the Affero General Public License version 3 or + * later. See the COPYING file. + */ + +(function(OC, OCA, $) { + OCA.Notifications = OCA.Notifications || {}; + OCA.Notifications.Components = OCA.Notifications.Components || {}; + + OCA.Notifications.Components.Root = { + template: '' + + '
' + + '
' + + ' ' + + '
' + + '
' + + '
' + + ' ' + + '
' + + '
' + + '

' + t('notifications', 'No notifications') + '

' + + '
' + + '
' + + '
', + + el: '#notifications', + data: { + hadNotifications: false, + backgroundFetching: false, + shutdown: false, + notifications: [] + }, + + _$el: null, + _$button: null, + _$icon: null, + _$container: null, + + computed: { + iconPath: function() { + var iconPath = 'notifications'; + + if (/*this.backgroundFetching &&*/ this.notifications.length) { + iconPath += '-new'; + } + + if (this.invertedTheme) { + iconPath += '-dark'; + } + + return OC.imagePath('notifications', iconPath); + }, + invertedTheme: function() { + return OCA.Theming && OCA.Theming.inverted; + } + }, + + methods: { + onRemove: function(index) { + this.notifications.splice(index, 1); + } + }, + + components: { + 'notification': OCA.Notifications.Components.Notification + }, + + mounted: function () { + this._$el = $(this.$el); + this._$button = this._$el.find('.notifications-button'); + this._$icon = this._$button.find('img'); + this._$container = this._$el.find('.notification-container'); + + // Bind the button click event + OC.registerMenu(this._$button, this._$container); + }, + + updated: function() { + this._$button.find('img').attr('src', this.iconPath); + + if (!this.hadNotifications && this.notifications.length) { + this._$icon + .animate({opacity: 0.6}, 600) + .animate({opacity: 1}, 600) + .animate({opacity: 0.6}, 600) + .animate({opacity: 1}, 600); + } + + this.hadNotifications = this.notifications.length > 0; + } + }; +})(OC, OCA, $); diff --git a/js/merged.json b/js/merged.json index a4ce30a5f..fe6ff81a5 100644 --- a/js/merged.json +++ b/js/merged.json @@ -1,5 +1,7 @@ [ + "components/action.js", + "components/notification.js", + "components/root.js", "app.js", - "notification.js", "richObjectStringParser.js" ] diff --git a/js/notification.js b/js/notification.js deleted file mode 100644 index 933e374b7..000000000 --- a/js/notification.js +++ /dev/null @@ -1,136 +0,0 @@ -/** - * @copyright (c) 2016 Joas Schilling - * @copyright (c) 2015 Tom Needham - * - * @author Tom Needham - * @author Joas Schilling - * - * This file is licensed under the Affero General Public License version 3 or - * later. See the COPYING file. - */ - -(function() { - - /** - * Initialise the notification - * - * @param {Object} data - * @param {int} data.notification_id - * @param {string} data.app - * @param {string} data.user - * @param {string} data.datetime - * @param {string} data.object_type - * @param {string} data.object_id - * @param {string} data.subject - * @param {string} data.subjectRich - * @param {Object[]} data.subjectRichParameters - * @param {string} data.message - * @param {string} data.link - * @param {string} data.icon - * @param {Object[]} data.actions - */ - OCA.Notifications.Notification = function(data) { - this.data = data; - }; - - OCA.Notifications.Notification.prototype = { - getId: function() { - return this.data.notification_id; - }, - - getApp: function() { - return this.data.app; - }, - - getUser: function() { - return this.data.user; - }, - - getTimestamp: function() { - if (_.isUndefined(this.data.timestamp)) { - this.data.timestamp = moment(this.data.datetime).format('X') * 1000; - } - - return this.data.timestamp; - }, - - getObjectType: function() { - return this.data.object_type; - }, - - getObjectId: function() { - return this.data.object_id; - }, - - getSubject: function() { - if (this.data.subjectRich.length !== 0) { - return OCA.Notifications.RichObjectStringParser.parseMessage( - this.data.subjectRich, - this.data.subjectRichParameters - ); - } - - return this.getPlainSubject(); - }, - - getPlainSubject: function() { - return this.data.subject; - }, - - getMessage: function() { - var message = this.data.message; - - /** - * Trim on word end after 180 chars or hard 200 chars - */ - if (message.length > 200) { - var spacePosition = message.indexOf(' ', 180); - if (spacePosition !== -1 && spacePosition <= 200) { - message = message.substring(0, spacePosition); - } else { - message = message.substring(0, 200); - } - message += '…'; - } - - return message.replace(new RegExp("\n", 'g'), ' '); - }, - - getLink: function() { - if (this.getSubject().indexOf('= 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, faster than native + */ +function bind (fn, ctx) { + function boundFn (a) { + var l = arguments.length; + return l + ? l > 1 + ? fn.apply(ctx, arguments) + : fn.call(ctx, a) + : fn.call(ctx) + } + // record original fn length + boundFn._length = fn.length; + return boundFn +} + +/** + * 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) + */ + 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 + */ + 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 +}); + +/* */ + +var emptyObject = Object.freeze({}); + +/** + * 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 + } +} + +/* */ + +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)) + ")") + } + }; +} + +/* */ + +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 && typeof console !== 'undefined') { + console.error(err); + } else { + throw err + } +} + +/* */ +/* globals MessageChannel */ + +// can we use __proto__? +var hasProto = '__proto__' in {}; + +// Browser environment sniffing +var inBrowser = typeof window !== 'undefined'; +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; +var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA); +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 && 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); + +/** + * Defer a task to execute it asynchronously. + */ +var nextTick = (function () { + var callbacks = []; + var pending = false; + var timerFunc; + + function nextTickHandler () { + pending = false; + var copies = callbacks.slice(0); + callbacks.length = 0; + for (var i = 0; i < copies.length; i++) { + copies[i](); + } + } + + // An asynchronous deferring mechanism. + // In pre 2.4, we used to use microtasks (Promise/MutationObserver) + // but microtasks actually has too high a priority and fires in between + // supposedly sequential events (e.g. #4521, #6690) or even between + // bubbling of the same event (#6566). Technically setImmediate should be + // the ideal choice, but it's not available everywhere; and 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)) { + timerFunc = function () { + setImmediate(nextTickHandler); + }; + } else if (typeof MessageChannel !== 'undefined' && ( + isNative(MessageChannel) || + // PhantomJS + MessageChannel.toString() === '[object MessageChannelConstructor]' + )) { + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = nextTickHandler; + timerFunc = function () { + port.postMessage(1); + }; + } else + /* istanbul ignore next */ + if (typeof Promise !== 'undefined' && isNative(Promise)) { + // use microtask in non-DOM environments, e.g. Weex + var p = Promise.resolve(); + timerFunc = function () { + p.then(nextTickHandler); + }; + } else { + // fallback to setTimeout + timerFunc = function () { + setTimeout(nextTickHandler, 0); + }; + } + + return function queueNextTick (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; + timerFunc(); + } + // $flow-disable-line + if (!cb && typeof Promise !== 'undefined') { + return new Promise(function (resolve, reject) { + _resolve = resolve; + }) + } + } +})(); + +var _Set; +/* istanbul ignore if */ // $flow-disable-line +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 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.functionalContext = undefined; + this.functionalOptions = undefined; + this.functionalScopeId = 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, deep) { + 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.isCloned = true; + if (deep && vnode.children) { + cloned.children = cloneVNodes(vnode.children); + } + return cloned +} + +function cloneVNodes (vnodes, deep) { + var len = vnodes.length; + var res = new Array(len); + for (var i = 0; i < len; i++) { + res[i] = cloneVNode(vnodes[i], deep); + } + return res +} + +/* + * 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);[ + 'push', + 'pop', + 'shift', + 'unshift', + 'splice', + 'sort', + 'reverse' +] +.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); + +/** + * By default, when a reactive property is set, the new value is + * also converted to become reactive. However when passing down props, + * we don't want to force conversion because the value may be a nested value + * under a frozen data structure. Converting it would defeat the optimization. + */ +var observerState = { + shouldConvert: true +}; + +/** + * Observer class that are attached to each observed + * object. Once attached, the observer converts target + * object's property keys into getter/setters that + * collect dependencies and dispatches 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], 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 ( + observerState.shouldConvert && + !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; + 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 (Array.isArray(target) && isValidArrayIndex(key)) { + target.length = Math.max(target.length, key); + target.splice(key, 1, val); + return val + } + if (hasOwn(target, key)) { + 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 (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) : childVal, + typeof parentVal === 'function' ? parentVal.call(this) : parentVal + ) + } + } else if (parentVal || childVal) { + return function mergedInstanceDataFn () { + // instance merge + var instanceData = typeof childVal === 'function' + ? childVal.call(vm) + : childVal; + var defaultData = typeof parentVal === 'function' + ? parentVal.call(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.call(this, 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) { + var lower = key.toLowerCase(); + if (isBuiltInTag(lower) || config.isReservedTag(lower)) { + warn( + 'Do not use built-in or reserved HTML elements as component ' + + 'id: ' + key + ); + } + } +} + +/** + * 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; + 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 if ("development" !== 'production' && inject) { + 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]; + // handle boolean props + if (isType(Boolean, prop.type)) { + if (absent && !hasOwn(prop, 'default')) { + value = false; + } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) { + 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 prevShouldConvert = observerState.shouldConvert; + observerState.shouldConvert = true; + observe(value); + observerState.shouldConvert = prevShouldConvert; + } + { + 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 isType (type, fn) { + if (!Array.isArray(fn)) { + return getType(fn) === getType(type) + } + for (var i = 0, len = fn.length; i < len; i++) { + if (getType(fn[i]) === getType(type)) { + return true + } + } + /* istanbul ignore next */ + return false +} + +/* */ + +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' && + Proxy.toString().match(/native code/); + + 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 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, cur, old, event; + for (name in on) { + cur = on[name]; + old = oldOn[name]; + event = normalizeEvent(name); + 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); + } 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) { + 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.