diff --git a/app.uhk.js b/app.uhk.js
index b9376c6c..076fa191 100644
--- a/app.uhk.js
+++ b/app.uhk.js
@@ -1,5 +1,19 @@
-webpackJsonp([1],Array(22).concat([
-/* 22 */
+webpackJsonp([1],[
+/* 0 */,
+/* 1 */,
+/* 2 */,
+/* 3 */,
+/* 4 */,
+/* 5 */,
+/* 6 */,
+/* 7 */,
+/* 8 */,
+/* 9 */,
+/* 10 */,
+/* 11 */,
+/* 12 */,
+/* 13 */,
+/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -8,21 +22,20 @@ function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(81));
-__export(__webpack_require__(1093));
-__export(__webpack_require__(1094));
-__export(__webpack_require__(1095));
-__export(__webpack_require__(1096));
-__export(__webpack_require__(1097));
-__export(__webpack_require__(1098));
-__export(__webpack_require__(1099));
+__export(__webpack_require__(47));
+__export(__webpack_require__(627));
+__export(__webpack_require__(628));
+__export(__webpack_require__(629));
+__export(__webpack_require__(630));
+__export(__webpack_require__(631));
+__export(__webpack_require__(632));
+__export(__webpack_require__(633));
/***/ }),
-/* 23 */,
-/* 24 */,
-/* 25 */,
-/* 26 */
+/* 15 */,
+/* 16 */,
+/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -103,11 +116,11 @@ exports.assertEnum = assertEnum;
/***/ }),
-/* 27 */,
-/* 28 */,
-/* 29 */,
-/* 30 */,
-/* 31 */
+/* 18 */,
+/* 19 */,
+/* 20 */,
+/* 21 */,
+/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -125,25 +138,68 @@ Object.defineProperty(exports, "__esModule", { value: true });
/* tslint:disable:variable-name */
var __svg__ = { filename: __webpack_require__.p +"assets/compiled_sprite.svg" };
/* tslint:enable:variable-name */
-var core_1 = __webpack_require__(0);
+var core_1 = __webpack_require__(1);
+var keystroke_type_1 = __webpack_require__(98);
var MapperService = (function () {
function MapperService() {
this.initScanCodeTextMap();
- this.initScanCodeFileName();
+ this.initScancodeIcons();
this.initNameToFileNames();
}
- MapperService.prototype.scanCodeToText = function (scanCode) {
- return this.scanCodeTextMap.get(scanCode);
- };
- MapperService.prototype.hasScancodeIcon = function (scancode) {
- return this.scanCodeFileName.has(scancode);
- };
- MapperService.prototype.scanCodeToSvgImagePath = function (scanCode) {
- var fileName = this.scanCodeFileName.get(scanCode);
- if (fileName) {
- return 'assets/compiled_sprite.svg#' + fileName;
+ MapperService.prototype.scanCodeToText = function (scanCode, type) {
+ if (type === void 0) { type = keystroke_type_1.KeystrokeType.basic; }
+ var map;
+ switch (type) {
+ case keystroke_type_1.KeystrokeType.shortMedia:
+ case keystroke_type_1.KeystrokeType.longMedia:
+ map = this.mediaScanCodeTextMap;
+ break;
+ case keystroke_type_1.KeystrokeType.system:
+ map = this.sytemScanCodeTextMap;
+ break;
+ default:
+ map = this.basicScanCodeTextMap;
+ break;
}
- return undefined;
+ return map.get(scanCode);
+ };
+ MapperService.prototype.hasScancodeIcon = function (scancode, type) {
+ if (type === void 0) { type = keystroke_type_1.KeystrokeType.basic; }
+ var map;
+ switch (type) {
+ case keystroke_type_1.KeystrokeType.basic:
+ map = this.basicScancodeIcons;
+ break;
+ case keystroke_type_1.KeystrokeType.shortMedia:
+ case keystroke_type_1.KeystrokeType.longMedia:
+ map = this.mediaScancodeIcons;
+ break;
+ case keystroke_type_1.KeystrokeType.system:
+ map = this.systemScancodeIcons;
+ break;
+ default:
+ map = new Map();
+ }
+ return map.has(scancode);
+ };
+ MapperService.prototype.scanCodeToSvgImagePath = function (scanCode, type) {
+ if (type === void 0) { type = keystroke_type_1.KeystrokeType.basic; }
+ var map;
+ switch (type) {
+ case keystroke_type_1.KeystrokeType.basic:
+ map = this.basicScancodeIcons;
+ break;
+ case keystroke_type_1.KeystrokeType.shortMedia:
+ case keystroke_type_1.KeystrokeType.longMedia:
+ map = this.mediaScancodeIcons;
+ break;
+ case keystroke_type_1.KeystrokeType.system:
+ map = this.systemScancodeIcons;
+ break;
+ default:
+ return undefined;
+ }
+ return 'assets/compiled_sprite.svg#' + map.get(scanCode);
};
MapperService.prototype.getIcon = function (iconName) {
return 'assets/compiled_sprite.svg#' + this.nameToFileName.get(iconName);
@@ -158,138 +214,163 @@ var MapperService = (function () {
};
// TODO: read the mapping from JSON
MapperService.prototype.initScanCodeTextMap = function () {
- this.scanCodeTextMap = new Map();
- this.scanCodeTextMap.set(4, ['A']);
- this.scanCodeTextMap.set(5, ['B']);
- this.scanCodeTextMap.set(6, ['C']);
- this.scanCodeTextMap.set(7, ['D']);
- this.scanCodeTextMap.set(8, ['E']);
- this.scanCodeTextMap.set(9, ['F']);
- this.scanCodeTextMap.set(10, ['G']);
- this.scanCodeTextMap.set(11, ['H']);
- this.scanCodeTextMap.set(12, ['I']);
- this.scanCodeTextMap.set(13, ['J']);
- this.scanCodeTextMap.set(14, ['K']);
- this.scanCodeTextMap.set(15, ['L']);
- this.scanCodeTextMap.set(16, ['M']);
- this.scanCodeTextMap.set(17, ['N']);
- this.scanCodeTextMap.set(18, ['O']);
- this.scanCodeTextMap.set(19, ['P']);
- this.scanCodeTextMap.set(20, ['Q']);
- this.scanCodeTextMap.set(21, ['R']);
- this.scanCodeTextMap.set(22, ['S']);
- this.scanCodeTextMap.set(23, ['T']);
- this.scanCodeTextMap.set(24, ['U']);
- this.scanCodeTextMap.set(25, ['V']);
- this.scanCodeTextMap.set(26, ['W']);
- this.scanCodeTextMap.set(27, ['X']);
- this.scanCodeTextMap.set(28, ['Y']);
- this.scanCodeTextMap.set(29, ['Z']);
- this.scanCodeTextMap.set(30, ['1', '!']);
- this.scanCodeTextMap.set(31, ['2', '@']);
- this.scanCodeTextMap.set(32, ['3', '#']);
- this.scanCodeTextMap.set(33, ['4', '$']);
- this.scanCodeTextMap.set(34, ['5', '%']);
- this.scanCodeTextMap.set(35, ['6', '^']);
- this.scanCodeTextMap.set(36, ['7', '&']);
- this.scanCodeTextMap.set(37, ['8', '*']);
- this.scanCodeTextMap.set(38, ['9', '(']);
- this.scanCodeTextMap.set(39, ['0', ')']);
- this.scanCodeTextMap.set(40, ['Enter']);
- this.scanCodeTextMap.set(41, ['Esc']);
- this.scanCodeTextMap.set(42, ['Backspace']);
- this.scanCodeTextMap.set(43, ['Tab']);
- this.scanCodeTextMap.set(44, ['Space']);
- this.scanCodeTextMap.set(45, ['-', '_']);
- this.scanCodeTextMap.set(46, ['=', '+']);
- this.scanCodeTextMap.set(47, ['[', '{']);
- this.scanCodeTextMap.set(48, [']', '}']);
- this.scanCodeTextMap.set(49, ['\\', '|']);
- this.scanCodeTextMap.set(50, ['NON_US_HASHMARK_AND_TILDE']);
- this.scanCodeTextMap.set(51, [';', ':']);
- this.scanCodeTextMap.set(52, ['\'', '"']);
- this.scanCodeTextMap.set(53, ['`', '~']);
- this.scanCodeTextMap.set(54, [',', '<']);
- this.scanCodeTextMap.set(55, ['.', '>']);
- this.scanCodeTextMap.set(56, ['/', '?']);
- this.scanCodeTextMap.set(57, ['Caps Lock']);
- this.scanCodeTextMap.set(58, ['F1']);
- this.scanCodeTextMap.set(59, ['F2']);
- this.scanCodeTextMap.set(60, ['F3']);
- this.scanCodeTextMap.set(61, ['F4']);
- this.scanCodeTextMap.set(62, ['F5']);
- this.scanCodeTextMap.set(63, ['F6']);
- this.scanCodeTextMap.set(64, ['F7']);
- this.scanCodeTextMap.set(65, ['F8']);
- this.scanCodeTextMap.set(66, ['F9']);
- this.scanCodeTextMap.set(67, ['F10']);
- this.scanCodeTextMap.set(68, ['F11']);
- this.scanCodeTextMap.set(69, ['F12']);
- this.scanCodeTextMap.set(70, ['PrtScn']);
- this.scanCodeTextMap.set(71, ['Scroll Lock']);
- this.scanCodeTextMap.set(72, ['Pause']);
- this.scanCodeTextMap.set(73, ['Insert']);
- this.scanCodeTextMap.set(74, ['Home']);
- this.scanCodeTextMap.set(75, ['PgUp']);
- this.scanCodeTextMap.set(76, ['Del']);
- this.scanCodeTextMap.set(77, ['End']);
- this.scanCodeTextMap.set(78, ['PgDn']);
- this.scanCodeTextMap.set(79, ['Right Arrow']);
- this.scanCodeTextMap.set(80, ['Left Arrow']);
- this.scanCodeTextMap.set(81, ['Down Arrow']);
- this.scanCodeTextMap.set(82, ['Up Arrow']);
- this.scanCodeTextMap.set(83, ['Num Lock']);
- this.scanCodeTextMap.set(84, ['/']);
- this.scanCodeTextMap.set(85, ['*']);
- this.scanCodeTextMap.set(86, ['-']);
- this.scanCodeTextMap.set(87, ['+']);
- this.scanCodeTextMap.set(88, ['Enter']);
- this.scanCodeTextMap.set(89, ['end', '1']);
- this.scanCodeTextMap.set(90, ['2']);
- this.scanCodeTextMap.set(91, ['pgdn', '3']);
- this.scanCodeTextMap.set(92, ['4']);
- this.scanCodeTextMap.set(93, ['5']);
- this.scanCodeTextMap.set(94, ['6']);
- this.scanCodeTextMap.set(95, ['home', '7']);
- this.scanCodeTextMap.set(96, ['8']);
- this.scanCodeTextMap.set(97, ['pgup', '9']);
- this.scanCodeTextMap.set(98, ['Insert', '0']);
- this.scanCodeTextMap.set(99, ['Del', '.']);
- this.scanCodeTextMap.set(104, ['F13']);
- this.scanCodeTextMap.set(105, ['F14']);
- this.scanCodeTextMap.set(106, ['F15']);
- this.scanCodeTextMap.set(107, ['F16']);
- this.scanCodeTextMap.set(108, ['F17']);
- this.scanCodeTextMap.set(109, ['F18']);
- this.scanCodeTextMap.set(110, ['F19']);
- this.scanCodeTextMap.set(111, ['F20']);
- this.scanCodeTextMap.set(112, ['F21']);
- this.scanCodeTextMap.set(113, ['F22']);
- this.scanCodeTextMap.set(114, ['F23']);
- this.scanCodeTextMap.set(115, ['F24']);
- this.scanCodeTextMap.set(118, ['Menu']);
- this.scanCodeTextMap.set(176, ['00']);
- this.scanCodeTextMap.set(177, ['000']);
- this.scanCodeTextMap.set(232, ['Play']);
- this.scanCodeTextMap.set(233, ['Stop']);
- this.scanCodeTextMap.set(234, ['Prev']);
- this.scanCodeTextMap.set(235, ['Next']);
- this.scanCodeTextMap.set(236, ['Eject']);
- this.scanCodeTextMap.set(237, ['Vol +']);
- this.scanCodeTextMap.set(238, ['Vol -']);
- this.scanCodeTextMap.set(239, ['Mute']);
- this.scanCodeTextMap.set(240, ['WWW']);
- this.scanCodeTextMap.set(241, ['Bckwrd']);
- this.scanCodeTextMap.set(242, ['Frwrd']);
- this.scanCodeTextMap.set(243, ['Cancel']);
+ this.basicScanCodeTextMap = new Map();
+ this.basicScanCodeTextMap.set(4, ['A']);
+ this.basicScanCodeTextMap.set(5, ['B']);
+ this.basicScanCodeTextMap.set(6, ['C']);
+ this.basicScanCodeTextMap.set(7, ['D']);
+ this.basicScanCodeTextMap.set(8, ['E']);
+ this.basicScanCodeTextMap.set(9, ['F']);
+ this.basicScanCodeTextMap.set(10, ['G']);
+ this.basicScanCodeTextMap.set(11, ['H']);
+ this.basicScanCodeTextMap.set(12, ['I']);
+ this.basicScanCodeTextMap.set(13, ['J']);
+ this.basicScanCodeTextMap.set(14, ['K']);
+ this.basicScanCodeTextMap.set(15, ['L']);
+ this.basicScanCodeTextMap.set(16, ['M']);
+ this.basicScanCodeTextMap.set(17, ['N']);
+ this.basicScanCodeTextMap.set(18, ['O']);
+ this.basicScanCodeTextMap.set(19, ['P']);
+ this.basicScanCodeTextMap.set(20, ['Q']);
+ this.basicScanCodeTextMap.set(21, ['R']);
+ this.basicScanCodeTextMap.set(22, ['S']);
+ this.basicScanCodeTextMap.set(23, ['T']);
+ this.basicScanCodeTextMap.set(24, ['U']);
+ this.basicScanCodeTextMap.set(25, ['V']);
+ this.basicScanCodeTextMap.set(26, ['W']);
+ this.basicScanCodeTextMap.set(27, ['X']);
+ this.basicScanCodeTextMap.set(28, ['Y']);
+ this.basicScanCodeTextMap.set(29, ['Z']);
+ this.basicScanCodeTextMap.set(30, ['1', '!']);
+ this.basicScanCodeTextMap.set(31, ['2', '@']);
+ this.basicScanCodeTextMap.set(32, ['3', '#']);
+ this.basicScanCodeTextMap.set(33, ['4', '$']);
+ this.basicScanCodeTextMap.set(34, ['5', '%']);
+ this.basicScanCodeTextMap.set(35, ['6', '^']);
+ this.basicScanCodeTextMap.set(36, ['7', '&']);
+ this.basicScanCodeTextMap.set(37, ['8', '*']);
+ this.basicScanCodeTextMap.set(38, ['9', '(']);
+ this.basicScanCodeTextMap.set(39, ['0', ')']);
+ this.basicScanCodeTextMap.set(40, ['Enter']);
+ this.basicScanCodeTextMap.set(41, ['Esc']);
+ this.basicScanCodeTextMap.set(42, ['Backspace']);
+ this.basicScanCodeTextMap.set(43, ['Tab']);
+ this.basicScanCodeTextMap.set(44, ['Space']);
+ this.basicScanCodeTextMap.set(45, ['-', '_']);
+ this.basicScanCodeTextMap.set(46, ['=', '+']);
+ this.basicScanCodeTextMap.set(47, ['[', '{']);
+ this.basicScanCodeTextMap.set(48, [']', '}']);
+ this.basicScanCodeTextMap.set(49, ['\\', '|']);
+ this.basicScanCodeTextMap.set(50, ['NON_US_HASHMARK_AND_TILDE']);
+ this.basicScanCodeTextMap.set(51, [';', ':']);
+ this.basicScanCodeTextMap.set(52, ['\'', '"']);
+ this.basicScanCodeTextMap.set(53, ['`', '~']);
+ this.basicScanCodeTextMap.set(54, [',', '<']);
+ this.basicScanCodeTextMap.set(55, ['.', '>']);
+ this.basicScanCodeTextMap.set(56, ['/', '?']);
+ this.basicScanCodeTextMap.set(57, ['Caps Lock']);
+ this.basicScanCodeTextMap.set(58, ['F1']);
+ this.basicScanCodeTextMap.set(59, ['F2']);
+ this.basicScanCodeTextMap.set(60, ['F3']);
+ this.basicScanCodeTextMap.set(61, ['F4']);
+ this.basicScanCodeTextMap.set(62, ['F5']);
+ this.basicScanCodeTextMap.set(63, ['F6']);
+ this.basicScanCodeTextMap.set(64, ['F7']);
+ this.basicScanCodeTextMap.set(65, ['F8']);
+ this.basicScanCodeTextMap.set(66, ['F9']);
+ this.basicScanCodeTextMap.set(67, ['F10']);
+ this.basicScanCodeTextMap.set(68, ['F11']);
+ this.basicScanCodeTextMap.set(69, ['F12']);
+ this.basicScanCodeTextMap.set(70, ['PrtScn']);
+ this.basicScanCodeTextMap.set(71, ['Scroll Lock']);
+ this.basicScanCodeTextMap.set(72, ['Pause']);
+ this.basicScanCodeTextMap.set(73, ['Insert']);
+ this.basicScanCodeTextMap.set(74, ['Home']);
+ this.basicScanCodeTextMap.set(75, ['PgUp']);
+ this.basicScanCodeTextMap.set(76, ['Del']);
+ this.basicScanCodeTextMap.set(77, ['End']);
+ this.basicScanCodeTextMap.set(78, ['PgDn']);
+ this.basicScanCodeTextMap.set(79, ['Right Arrow']);
+ this.basicScanCodeTextMap.set(80, ['Left Arrow']);
+ this.basicScanCodeTextMap.set(81, ['Down Arrow']);
+ this.basicScanCodeTextMap.set(82, ['Up Arrow']);
+ this.basicScanCodeTextMap.set(83, ['Num Lock']);
+ this.basicScanCodeTextMap.set(84, ['/']);
+ this.basicScanCodeTextMap.set(85, ['*']);
+ this.basicScanCodeTextMap.set(86, ['-']);
+ this.basicScanCodeTextMap.set(87, ['+']);
+ this.basicScanCodeTextMap.set(88, ['Enter']);
+ this.basicScanCodeTextMap.set(89, ['end', '1']);
+ this.basicScanCodeTextMap.set(90, ['2']);
+ this.basicScanCodeTextMap.set(91, ['pgdn', '3']);
+ this.basicScanCodeTextMap.set(92, ['4']);
+ this.basicScanCodeTextMap.set(93, ['5']);
+ this.basicScanCodeTextMap.set(94, ['6']);
+ this.basicScanCodeTextMap.set(95, ['home', '7']);
+ this.basicScanCodeTextMap.set(96, ['8']);
+ this.basicScanCodeTextMap.set(97, ['pgup', '9']);
+ this.basicScanCodeTextMap.set(98, ['Insert', '0']);
+ this.basicScanCodeTextMap.set(99, ['Del', '.']);
+ this.basicScanCodeTextMap.set(104, ['F13']);
+ this.basicScanCodeTextMap.set(105, ['F14']);
+ this.basicScanCodeTextMap.set(106, ['F15']);
+ this.basicScanCodeTextMap.set(107, ['F16']);
+ this.basicScanCodeTextMap.set(108, ['F17']);
+ this.basicScanCodeTextMap.set(109, ['F18']);
+ this.basicScanCodeTextMap.set(110, ['F19']);
+ this.basicScanCodeTextMap.set(111, ['F20']);
+ this.basicScanCodeTextMap.set(112, ['F21']);
+ this.basicScanCodeTextMap.set(113, ['F22']);
+ this.basicScanCodeTextMap.set(114, ['F23']);
+ this.basicScanCodeTextMap.set(115, ['F24']);
+ this.basicScanCodeTextMap.set(118, ['Menu']);
+ this.basicScanCodeTextMap.set(176, ['00']);
+ this.basicScanCodeTextMap.set(177, ['000']);
+ this.mediaScanCodeTextMap = new Map();
+ this.mediaScanCodeTextMap.set(138, ['WWW']);
+ this.mediaScanCodeTextMap.set(176, ['Play']);
+ this.mediaScanCodeTextMap.set(177, ['Pause']);
+ this.mediaScanCodeTextMap.set(181, ['Next']);
+ this.mediaScanCodeTextMap.set(182, ['Prev']);
+ this.mediaScanCodeTextMap.set(183, ['Stop']);
+ this.mediaScanCodeTextMap.set(184, ['Eject']);
+ this.mediaScanCodeTextMap.set(204, ['Eject', 'Stop']);
+ this.mediaScanCodeTextMap.set(205, ['Pause', 'Play']);
+ this.mediaScanCodeTextMap.set(226, ['Mute']);
+ this.mediaScanCodeTextMap.set(233, ['Vol +']);
+ this.mediaScanCodeTextMap.set(234, ['Vol -']);
+ this.mediaScanCodeTextMap.set(406, ['Launch Web Browser']);
+ this.mediaScanCodeTextMap.set(394, ['Launch Email Client']);
+ this.mediaScanCodeTextMap.set(402, ['Launch Calculator']);
+ this.sytemScanCodeTextMap = new Map();
+ this.sytemScanCodeTextMap.set(129, ['Power Down']);
+ this.sytemScanCodeTextMap.set(130, ['Sleep']);
+ this.sytemScanCodeTextMap.set(131, ['Wake Up']);
};
- MapperService.prototype.initScanCodeFileName = function () {
- this.scanCodeFileName = new Map();
- this.scanCodeFileName.set(79, 'icon-kbd__mod--arrow-right');
- this.scanCodeFileName.set(80, 'icon-kbd__mod--arrow-left');
- this.scanCodeFileName.set(81, 'icon-kbd__mod--arrow-down');
- this.scanCodeFileName.set(82, 'icon-kbd__mod--arrow-up');
- this.scanCodeFileName.set(118, 'icon-kbd__mod--menu');
+ MapperService.prototype.initScancodeIcons = function () {
+ this.basicScancodeIcons = new Map();
+ this.basicScancodeIcons.set(79, 'icon-kbd__mod--arrow-right');
+ this.basicScancodeIcons.set(80, 'icon-kbd__mod--arrow-left');
+ this.basicScancodeIcons.set(81, 'icon-kbd__mod--arrow-down');
+ this.basicScancodeIcons.set(82, 'icon-kbd__mod--arrow-up');
+ this.basicScancodeIcons.set(118, 'icon-kbd__mod--menu');
+ this.mediaScancodeIcons = new Map();
+ this.mediaScancodeIcons.set(138, 'icon-kbd__fn--browser');
+ this.mediaScancodeIcons.set(176, 'icon-kbd__media--play');
+ this.mediaScancodeIcons.set(177, 'icon-kbd__media--pause');
+ this.mediaScancodeIcons.set(181, 'icon-kbd__media--next');
+ this.mediaScancodeIcons.set(182, 'icon-kbd__media--prev');
+ this.mediaScancodeIcons.set(184, 'icon-kbd__fn--eject');
+ this.mediaScancodeIcons.set(226, 'icon-kbd__media--mute');
+ this.mediaScancodeIcons.set(233, 'icon-kbd__media--vol-up');
+ this.mediaScancodeIcons.set(234, 'icon-kbd__media--vol-down');
+ this.mediaScancodeIcons.set(406, 'icon-kbd__media--web-browser');
+ this.mediaScancodeIcons.set(394, 'icon-kbd__media--email-client');
+ this.mediaScancodeIcons.set(402, 'icon-kbd__media--calculator');
+ this.systemScancodeIcons = new Map();
+ this.systemScancodeIcons.set(129, 'icon-kbd__system_power_down');
+ this.systemScancodeIcons.set(130, 'icon-kbd__system_sleep');
+ this.systemScancodeIcons.set(131, 'icon-kbd__system_wake_up');
};
MapperService.prototype.initNameToFileNames = function () {
this.nameToFileName = new Map();
@@ -319,29 +400,1271 @@ exports.MapperService = MapperService;
/***/ }),
+/* 23 */,
+/* 24 */,
+/* 25 */,
+/* 26 */,
+/* 27 */,
+/* 28 */,
+/* 29 */,
+/* 30 */,
+/* 31 */,
/* 32 */,
-/* 33 */,
-/* 34 */,
-/* 35 */,
-/* 36 */,
-/* 37 */,
-/* 38 */,
-/* 39 */,
-/* 40 */,
-/* 41 */,
-/* 42 */,
-/* 43 */,
-/* 44 */,
-/* 45 */,
-/* 46 */,
-/* 47 */,
-/* 48 */,
-/* 49 */,
-/* 50 */,
-/* 51 */,
-/* 52 */,
-/* 53 */,
-/* 54 */
+/* 33 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AnimationBuilder", function() { return AnimationBuilder; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AnimationFactory", function() { return AnimationFactory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AUTO_STYLE", function() { return AUTO_STYLE; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "animate", function() { return animate; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "animateChild", function() { return animateChild; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "animation", function() { return animation; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "group", function() { return group; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "keyframes", function() { return keyframes; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "query", function() { return query; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sequence", function() { return sequence; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stagger", function() { return stagger; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "state", function() { return state; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "style", function() { return style; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transition", function() { return transition; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "trigger", function() { return trigger; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useAnimation", function() { return useAnimation; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NoopAnimationPlayer", function() { return NoopAnimationPlayer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵAnimationGroupPlayer", function() { return AnimationGroupPlayer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵPRE_STYLE", function() { return ɵPRE_STYLE; });
+/**
+ * @license Angular v4.2.6
+ * (c) 2010-2017 Google, Inc. https://angular.io/
+ * License: MIT
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * AnimationBuilder is an injectable service that is available when the {\@link
+ * BrowserAnimationsModule BrowserAnimationsModule} or {\@link NoopAnimationsModule
+ * NoopAnimationsModule} modules are used within an application.
+ *
+ * The purpose if this service is to produce an animation sequence programmatically within an
+ * angular component or directive.
+ *
+ * Programmatic animations are first built and then a player is created when the build animation is
+ * attached to an element.
+ *
+ * ```ts
+ * // remember to include the BrowserAnimationsModule module for this to work...
+ * import {AnimationBuilder} from '\@angular/animations';
+ *
+ * class MyCmp {
+ * constructor(private _builder: AnimationBuilder) {}
+ *
+ * makeAnimation(element: any) {
+ * // first build the animation
+ * const myAnimation = this._builder.build([
+ * style({ width: 0 }),
+ * animate(1000, style({ width: '100px' }))
+ * ]);
+ *
+ * // then create a player from it
+ * const player = myAnimation.create(element);
+ *
+ * player.play();
+ * }
+ * }
+ * ```
+ *
+ * When an animation is built an instance of {\@link AnimationFactory AnimationFactory} will be
+ * returned. Using that an {\@link AnimationPlayer AnimationPlayer} can be created which can then be
+ * used to start the animation.
+ *
+ * \@experimental Animation support is experimental.
+ * @abstract
+ */
+var AnimationBuilder = (function () {
+ function AnimationBuilder() {
+ }
+ /**
+ * @abstract
+ * @param {?} animation
+ * @return {?}
+ */
+ AnimationBuilder.prototype.build = function (animation) { };
+ return AnimationBuilder;
+}());
+/**
+ * An instance of `AnimationFactory` is returned from {\@link AnimationBuilder#build
+ * AnimationBuilder.build}.
+ *
+ * \@experimental Animation support is experimental.
+ * @abstract
+ */
+var AnimationFactory = (function () {
+ function AnimationFactory() {
+ }
+ /**
+ * @abstract
+ * @param {?} element
+ * @param {?=} options
+ * @return {?}
+ */
+ AnimationFactory.prototype.create = function (element, options) { };
+ return AnimationFactory;
+}());
+/**
+ * \@experimental Animation support is experimental.
+ */
+var AUTO_STYLE = '*';
+/**
+ * `trigger` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `trigger` Creates an animation trigger which will a list of {\@link state state} and {\@link
+ * transition transition} entries that will be evaluated when the expression bound to the trigger
+ * changes.
+ *
+ * Triggers are registered within the component annotation data under the {\@link
+ * Component#animations animations section}. An animation trigger can be placed on an element
+ * within a template by referencing the name of the trigger followed by the expression value that the
+ * trigger is bound to (in the form of `[\@triggerName]="expression"`.
+ *
+ * ### Usage
+ *
+ * `trigger` will create an animation trigger reference based on the provided `name` value. The
+ * provided `animation` value is expected to be an array consisting of {\@link state state} and {\@link
+ * transition transition} declarations.
+ *
+ * ```typescript
+ * \@Component({
+ * selector: 'my-component',
+ * templateUrl: 'my-component-tpl.html',
+ * animations: [
+ * trigger("myAnimationTrigger", [
+ * state(...),
+ * state(...),
+ * transition(...),
+ * transition(...)
+ * ])
+ * ]
+ * })
+ * class MyComponent {
+ * myStatusExp = "something";
+ * }
+ * ```
+ *
+ * The template associated with this component will make use of the `myAnimationTrigger` animation
+ * trigger by binding to an element within its template code.
+ *
+ * ```html
+ *
+ *
...
+ * tools/gulp-tasks/validate-commit-message.js ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} name
+ * @param {?} definitions
+ * @return {?}
+ */
+function trigger(name, definitions) {
+ return { type: 7 /* Trigger */, name: name, definitions: definitions, options: {} };
+}
+/**
+ * `animate` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `animate` specifies an animation step that will apply the provided `styles` data for a given
+ * amount of time based on the provided `timing` expression value. Calls to `animate` are expected
+ * to be used within {\@link sequence an animation sequence}, {\@link group group}, or {\@link
+ * transition transition}.
+ *
+ * ### Usage
+ *
+ * The `animate` function accepts two input parameters: `timing` and `styles`:
+ *
+ * - `timing` is a string based value that can be a combination of a duration with optional delay
+ * and easing values. The format for the expression breaks down to `duration delay easing`
+ * (therefore a value such as `1s 100ms ease-out` will be parse itself into `duration=1000,
+ * delay=100, easing=ease-out`. If a numeric value is provided then that will be used as the
+ * `duration` value in millisecond form.
+ * - `styles` is the style input data which can either be a call to {\@link style style} or {\@link
+ * keyframes keyframes}. If left empty then the styles from the destination state will be collected
+ * and used (this is useful when describing an animation step that will complete an animation by
+ * {\@link transition#the-final-animate-call animating to the final state}).
+ *
+ * ```typescript
+ * // various functions for specifying timing data
+ * animate(500, style(...))
+ * animate("1s", style(...))
+ * animate("100ms 0.5s", style(...))
+ * animate("5s ease", style(...))
+ * animate("5s 10ms cubic-bezier(.17,.67,.88,.1)", style(...))
+ *
+ * // either style() of keyframes() can be used
+ * animate(500, style({ background: "red" }))
+ * animate(500, keyframes([
+ * style({ background: "blue" })),
+ * style({ background: "red" }))
+ * ])
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} timings
+ * @param {?=} styles
+ * @return {?}
+ */
+function animate(timings, styles) {
+ if (styles === void 0) { styles = null; }
+ return { type: 4 /* Animate */, styles: styles, timings: timings };
+}
+/**
+ * `group` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `group` specifies a list of animation steps that are all run in parallel. Grouped animations are
+ * useful when a series of styles must be animated/closed off at different starting/ending times.
+ *
+ * The `group` function can either be used within a {\@link sequence sequence} or a {\@link transition
+ * transition} and it will only continue to the next instruction once all of the inner animation
+ * steps have completed.
+ *
+ * ### Usage
+ *
+ * The `steps` data that is passed into the `group` animation function can either consist of {\@link
+ * style style} or {\@link animate animate} function calls. Each call to `style()` or `animate()`
+ * within a group will be executed instantly (use {\@link keyframes keyframes} or a {\@link
+ * animate#usage animate() with a delay value} to offset styles to be applied at a later time).
+ *
+ * ```typescript
+ * group([
+ * animate("1s", { background: "black" }))
+ * animate("2s", { color: "white" }))
+ * ])
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} steps
+ * @param {?=} options
+ * @return {?}
+ */
+function group(steps, options) {
+ if (options === void 0) { options = null; }
+ return { type: 3 /* Group */, steps: steps, options: options };
+}
+/**
+ * `sequence` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `sequence` Specifies a list of animation steps that are run one by one. (`sequence` is used by
+ * default when an array is passed as animation data into {\@link transition transition}.)
+ *
+ * The `sequence` function can either be used within a {\@link group group} or a {\@link transition
+ * transition} and it will only continue to the next instruction once each of the inner animation
+ * steps have completed.
+ *
+ * To perform animation styling in parallel with other animation steps then have a look at the
+ * {\@link group group} animation function.
+ *
+ * ### Usage
+ *
+ * The `steps` data that is passed into the `sequence` animation function can either consist of
+ * {\@link style style} or {\@link animate animate} function calls. A call to `style()` will apply the
+ * provided styling data immediately while a call to `animate()` will apply its styling data over a
+ * given time depending on its timing data.
+ *
+ * ```typescript
+ * sequence([
+ * style({ opacity: 0 })),
+ * animate("1s", { opacity: 1 }))
+ * ])
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} steps
+ * @param {?=} options
+ * @return {?}
+ */
+function sequence(steps, options) {
+ if (options === void 0) { options = null; }
+ return { type: 2 /* Sequence */, steps: steps, options: options };
+}
+/**
+ * `style` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `style` declares a key/value object containing CSS properties/styles that can then be used for
+ * {\@link state animation states}, within an {\@link sequence animation sequence}, or as styling data
+ * for both {\@link animate animate} and {\@link keyframes keyframes}.
+ *
+ * ### Usage
+ *
+ * `style` takes in a key/value string map as data and expects one or more CSS property/value pairs
+ * to be defined.
+ *
+ * ```typescript
+ * // string values are used for css properties
+ * style({ background: "red", color: "blue" })
+ *
+ * // numerical (pixel) values are also supported
+ * style({ width: 100, height: 0 })
+ * ```
+ *
+ * #### Auto-styles (using `*`)
+ *
+ * When an asterix (`*`) character is used as a value then it will be detected from the element
+ * being animated and applied as animation data when the animation starts.
+ *
+ * This feature proves useful for a state depending on layout and/or environment factors; in such
+ * cases the styles are calculated just before the animation starts.
+ *
+ * ```typescript
+ * // the steps below will animate from 0 to the
+ * // actual height of the element
+ * style({ height: 0 }),
+ * animate("1s", style({ height: "*" }))
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} tokens
+ * @return {?}
+ */
+function style(tokens) {
+ return { type: 6 /* Style */, styles: tokens, offset: null };
+}
+/**
+ * `state` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `state` declares an animation state within the given trigger. When a state is active within a
+ * component then its associated styles will persist on the element that the trigger is attached to
+ * (even when the animation ends).
+ *
+ * To animate between states, have a look at the animation {\@link transition transition} DSL
+ * function. To register states to an animation trigger please have a look at the {\@link trigger
+ * trigger} function.
+ *
+ * #### The `void` state
+ *
+ * The `void` state value is a reserved word that angular uses to determine when the element is not
+ * apart of the application anymore (e.g. when an `ngIf` evaluates to false then the state of the
+ * associated element is void).
+ *
+ * #### The `*` (default) state
+ *
+ * The `*` state (when styled) is a fallback state that will be used if the state that is being
+ * animated is not declared within the trigger.
+ *
+ * ### Usage
+ *
+ * `state` will declare an animation state with its associated styles
+ * within the given trigger.
+ *
+ * - `stateNameExpr` can be one or more state names separated by commas.
+ * - `styles` refers to the {\@link style styling data} that will be persisted on the element once
+ * the state has been reached.
+ *
+ * ```typescript
+ * // "void" is a reserved name for a state and is used to represent
+ * // the state in which an element is detached from from the application.
+ * state("void", style({ height: 0 }))
+ *
+ * // user-defined states
+ * state("closed", style({ height: 0 }))
+ * state("open, visible", style({ height: "*" }))
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} name
+ * @param {?} styles
+ * @return {?}
+ */
+function state(name, styles) {
+ return { type: 0 /* State */, name: name, styles: styles };
+}
+/**
+ * `keyframes` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `keyframes` specifies a collection of {\@link style style} entries each optionally characterized
+ * by an `offset` value.
+ *
+ * ### Usage
+ *
+ * The `keyframes` animation function is designed to be used alongside the {\@link animate animate}
+ * animation function. Instead of applying animations from where they are currently to their
+ * destination, keyframes can describe how each style entry is applied and at what point within the
+ * animation arc (much like CSS Keyframe Animations do).
+ *
+ * For each `style()` entry an `offset` value can be set. Doing so allows to specifiy at what
+ * percentage of the animate time the styles will be applied.
+ *
+ * ```typescript
+ * // the provided offset values describe when each backgroundColor value is applied.
+ * animate("5s", keyframes([
+ * style({ backgroundColor: "red", offset: 0 }),
+ * style({ backgroundColor: "blue", offset: 0.2 }),
+ * style({ backgroundColor: "orange", offset: 0.3 }),
+ * style({ backgroundColor: "black", offset: 1 })
+ * ]))
+ * ```
+ *
+ * Alternatively, if there are no `offset` values used within the style entries then the offsets
+ * will be calculated automatically.
+ *
+ * ```typescript
+ * animate("5s", keyframes([
+ * style({ backgroundColor: "red" }) // offset = 0
+ * style({ backgroundColor: "blue" }) // offset = 0.33
+ * style({ backgroundColor: "orange" }) // offset = 0.66
+ * style({ backgroundColor: "black" }) // offset = 1
+ * ]))
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} steps
+ * @return {?}
+ */
+function keyframes(steps) {
+ return { type: 5 /* Keyframes */, steps: steps };
+}
+/**
+ * `transition` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. If this information is new, please navigate to the {\@link
+ * Component#animations component animations metadata page} to gain a better understanding of
+ * how animations in Angular are used.
+ *
+ * `transition` declares the {\@link sequence sequence of animation steps} that will be run when the
+ * provided `stateChangeExpr` value is satisfied. The `stateChangeExpr` consists of a `state1 =>
+ * state2` which consists of two known states (use an asterix (`*`) to refer to a dynamic starting
+ * and/or ending state).
+ *
+ * A function can also be provided as the `stateChangeExpr` argument for a transition and this
+ * function will be executed each time a state change occurs. If the value returned within the
+ * function is true then the associated animation will be run.
+ *
+ * Animation transitions are placed within an {\@link trigger animation trigger}. For an transition
+ * to animate to a state value and persist its styles then one or more {\@link state animation
+ * states} is expected to be defined.
+ *
+ * ### Usage
+ *
+ * An animation transition is kicked off the `stateChangeExpr` predicate evaluates to true based on
+ * what the previous state is and what the current state has become. In other words, if a transition
+ * is defined that matches the old/current state criteria then the associated animation will be
+ * triggered.
+ *
+ * ```typescript
+ * // all transition/state changes are defined within an animation trigger
+ * trigger("myAnimationTrigger", [
+ * // if a state is defined then its styles will be persisted when the
+ * // animation has fully completed itself
+ * state("on", style({ background: "green" })),
+ * state("off", style({ background: "grey" })),
+ *
+ * // a transition animation that will be kicked off when the state value
+ * // bound to "myAnimationTrigger" changes from "on" to "off"
+ * transition("on => off", animate(500)),
+ *
+ * // it is also possible to do run the same animation for both directions
+ * transition("on <=> off", animate(500)),
+ *
+ * // or to define multiple states pairs separated by commas
+ * transition("on => off, off => void", animate(500)),
+ *
+ * // this is a catch-all state change for when an element is inserted into
+ * // the page and the destination state is unknown
+ * transition("void => *", [
+ * style({ opacity: 0 }),
+ * animate(500)
+ * ]),
+ *
+ * // this will capture a state change between any states
+ * transition("* => *", animate("1s 0s")),
+ *
+ * // you can also go full out and include a function
+ * transition((fromState, toState) => {
+ * // when `true` then it will allow the animation below to be invoked
+ * return fromState == "off" && toState == "on";
+ * }, animate("1s 0s"))
+ * ])
+ * ```
+ *
+ * The template associated with this component will make use of the `myAnimationTrigger` animation
+ * trigger by binding to an element within its template code.
+ *
+ * ```html
+ *
+ *
...
+ * ```
+ *
+ * #### The final `animate` call
+ *
+ * If the final step within the transition steps is a call to `animate()` that **only** uses a
+ * timing value with **no style data** then it will be automatically used as the final animation arc
+ * for the element to animate itself to the final state. This involves an automatic mix of
+ * adding/removing CSS styles so that the element will be in the exact state it should be for the
+ * applied state to be presented correctly.
+ *
+ * ```
+ * // start off by hiding the element, but make sure that it animates properly to whatever state
+ * // is currently active for "myAnimationTrigger"
+ * transition("void => *", [
+ * style({ opacity: 0 }),
+ * animate(500)
+ * ])
+ * ```
+ *
+ * ### Transition Aliases (`:enter` and `:leave`)
+ *
+ * Given that enter (insertion) and leave (removal) animations are so common, the `transition`
+ * function accepts both `:enter` and `:leave` values which are aliases for the `void => *` and `*
+ * => void` state changes.
+ *
+ * ```
+ * transition(":enter", [
+ * style({ opacity: 0 }),
+ * animate(500, style({ opacity: 1 }))
+ * ])
+ * transition(":leave", [
+ * animate(500, style({ opacity: 0 }))
+ * ])
+ * ```
+ *
+ * {\@example core/animation/ts/dsl/animation_example.ts region='Component'}
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} stateChangeExpr
+ * @param {?} steps
+ * @param {?=} options
+ * @return {?}
+ */
+function transition(stateChangeExpr, steps, options) {
+ if (options === void 0) { options = null; }
+ return { type: 1 /* Transition */, expr: stateChangeExpr, animation: steps, options: options };
+}
+/**
+ * `animation` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language.
+ *
+ * `var myAnimation = animation(...)` is designed to produce a reusable animation that can be later
+ * invoked in another animation or sequence. Reusable animations are designed to make use of
+ * animation parameters and the produced animation can be used via the `useAnimation` method.
+ *
+ * ```
+ * var fadeAnimation = animation([
+ * style({ opacity: '{{ start }}' }),
+ * animate('{{ time }}',
+ * style({ opacity: '{{ end }}'))
+ * ], { params: { time: '1000ms', start: 0, end: 1 }});
+ * ```
+ *
+ * If parameters are attached to an animation then they act as **default parameter values**. When an
+ * animation is invoked via `useAnimation` then parameter values are allowed to be passed in
+ * directly. If any of the passed in parameter values are missing then the default values will be
+ * used.
+ *
+ * ```
+ * useAnimation(fadeAnimation, {
+ * params: {
+ * time: '2s',
+ * start: 1,
+ * end: 0
+ * }
+ * })
+ * ```
+ *
+ * If one or more parameter values are missing before animated then an error will be thrown.
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} steps
+ * @param {?=} options
+ * @return {?}
+ */
+function animation(steps, options) {
+ if (options === void 0) { options = null; }
+ return { type: 8 /* Reference */, animation: steps, options: options };
+}
+/**
+ * `animateChild` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. It works by allowing a queried element to execute its own
+ * animation within the animation sequence.
+ *
+ * Each time an animation is triggered in angular, the parent animation
+ * will always get priority and any child animations will be blocked. In order
+ * for a child animation to run, the parent animation must query each of the elements
+ * containing child animations and then allow the animations to run using `animateChild`.
+ *
+ * The example HTML code below shows both parent and child elements that have animation
+ * triggers that will execute at the same time.
+ *
+ * ```html
+ *
+ *
+ *
+ *
+ *
+ * Hello
+ *
+ * one
+ *
+ *
+ * two
+ *
+ *
+ * three
+ *
+ *
+ * ```
+ *
+ * Now when the `exp` value changes to true, only the `parentAnimation` animation will animate
+ * because it has priority. However, using `query` and `animateChild` each of the inner animations
+ * can also fire:
+ *
+ * ```ts
+ * // parent-child.component.ts
+ * import {trigger, transition, animate, style, query, animateChild} from '\@angular/animations';
+ * \@Component({
+ * selector: 'parent-child-component',
+ * animations: [
+ * trigger('parentAnimation', [
+ * transition('false => true', [
+ * query('header', [
+ * style({ opacity: 0 }),
+ * animate(500, style({ opacity: 1 }))
+ * ]),
+ * query('\@childAnimation', [
+ * animateChild()
+ * ])
+ * ])
+ * ]),
+ * trigger('childAnimation', [
+ * transition('false => true', [
+ * style({ opacity: 0 }),
+ * animate(500, style({ opacity: 1 }))
+ * ])
+ * ])
+ * ]
+ * })
+ * class ParentChildCmp {
+ * exp: boolean = false;
+ * }
+ * ```
+ *
+ * In the animation code above, when the `parentAnimation` transition kicks off it first queries to
+ * find the header element and fades it in. It then finds each of the sub elements that contain the
+ * `\@childAnimation` trigger and then allows for their animations to fire.
+ *
+ * This example can be further extended by using stagger:
+ *
+ * ```ts
+ * query('\@childAnimation', stagger(100, [
+ * animateChild()
+ * ]))
+ * ```
+ *
+ * Now each of the sub animations start off with respect to the `100ms` staggering step.
+ *
+ * ## The first frame of child animations
+ * When sub animations are executed using `animateChild` the animation engine will always apply the
+ * first frame of every sub animation immediately at the start of the animation sequence. This way
+ * the parent animation does not need to set any initial styling data on the sub elements before the
+ * sub animations kick off.
+ *
+ * In the example above the first frame of the `childAnimation`'s `false => true` transition
+ * consists of a style of `opacity: 0`. This is applied immediately when the `parentAnimation`
+ * animation transition sequence starts. Only then when the `\@childAnimation` is queried and called
+ * with `animateChild` will it then animate to its destination of `opacity: 1`.
+ *
+ * Note that this feature designed to be used alongside {\@link query query()} and it will only work
+ * with animations that are assigned using the Angular animation DSL (this means that CSS keyframes
+ * and transitions are not handled by this API).
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?=} options
+ * @return {?}
+ */
+function animateChild(options) {
+ if (options === void 0) { options = null; }
+ return { type: 9 /* AnimateChild */, options: options };
+}
+/**
+ * `useAnimation` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. It is used to kick off a reusable animation that is created using {\@link
+ * animation animation()}.
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} animation
+ * @param {?=} options
+ * @return {?}
+ */
+function useAnimation(animation, options) {
+ if (options === void 0) { options = null; }
+ return { type: 10 /* AnimateRef */, animation: animation, options: options };
+}
+/**
+ * `query` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language.
+ *
+ * query() is used to find one or more inner elements within the current element that is
+ * being animated within the sequence. The provided animation steps are applied
+ * to the queried element (by default, an array is provided, then this will be
+ * treated as an animation sequence).
+ *
+ * ### Usage
+ *
+ * query() is designed to collect mutiple elements and works internally by using
+ * `element.querySelectorAll`. An additional options object can be provided which
+ * can be used to limit the total amount of items to be collected.
+ *
+ * ```js
+ * query('div', [
+ * animate(...),
+ * animate(...)
+ * ], { limit: 1 })
+ * ```
+ *
+ * query(), by default, will throw an error when zero items are found. If a query
+ * has the `optional` flag set to true then this error will be ignored.
+ *
+ * ```js
+ * query('.some-element-that-may-not-be-there', [
+ * animate(...),
+ * animate(...)
+ * ], { optional: true })
+ * ```
+ *
+ * ### Special Selector Values
+ *
+ * The selector value within a query can collect elements that contain angular-specific
+ * characteristics
+ * using special pseudo-selectors tokens.
+ *
+ * These include:
+ *
+ * - Querying for newly inserted/removed elements using `query(":enter")`/`query(":leave")`
+ * - Querying all currently animating elements using `query(":animating")`
+ * - Querying elements that contain an animation trigger using `query("\@triggerName")`
+ * - Querying all elements that contain an animation triggers using `query("\@*")`
+ * - Including the current element into the animation sequence using `query(":self")`
+ *
+ *
+ * Each of these pseudo-selector tokens can be merged together into a combined query selector
+ * string:
+ *
+ * ```
+ * query(':self, .record:enter, .record:leave, \@subTrigger', [...])
+ * ```
+ *
+ * ### Demo
+ *
+ * ```
+ * \@Component({
+ * selector: 'inner',
+ * template: `
+ *
+ *
Title
+ *
+ * Blah blah blah
+ *
+ *
+ * `,
+ * animations: [
+ * trigger('queryAnimation', [
+ * transition('* => goAnimate', [
+ * // hide the inner elements
+ * query('h1', style({ opacity: 0 })),
+ * query('.content', style({ opacity: 0 })),
+ *
+ * // animate the inner elements in, one by one
+ * query('h1', animate(1000, style({ opacity: 1 })),
+ * query('.content', animate(1000, style({ opacity: 1 })),
+ * ])
+ * ])
+ * ]
+ * })
+ * class Cmp {
+ * exp = '';
+ *
+ * goAnimate() {
+ * this.exp = 'goAnimate';
+ * }
+ * }
+ * ```
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} selector
+ * @param {?} animation
+ * @param {?=} options
+ * @return {?}
+ */
+function query(selector, animation, options) {
+ if (options === void 0) { options = null; }
+ return { type: 11 /* Query */, selector: selector, animation: animation, options: options };
+}
+/**
+ * `stagger` is an animation-specific function that is designed to be used inside of Angular's
+ * animation DSL language. It is designed to be used inside of an animation {\@link query query()}
+ * and works by issuing a timing gap between after each queried item is animated.
+ *
+ * ### Usage
+ *
+ * In the example below there is a container element that wraps a list of items stamped out
+ * by an ngFor. The container element contains an animation trigger that will later be set
+ * to query for each of the inner items.
+ *
+ * ```html
+ *
+ *
+ *
+ *
+ *
+ * {{ item }}
+ *
+ *
+ * ```
+ *
+ * The component code for this looks as such:
+ *
+ * ```ts
+ * import {trigger, transition, style, animate, query, stagger} from '\@angular/animations';
+ * \@Component({
+ * templateUrl: 'list.component.html',
+ * animations: [
+ * trigger('listAnimation', [
+ * //...
+ * ])
+ * ]
+ * })
+ * class ListComponent {
+ * items = [];
+ *
+ * showItems() {
+ * this.items = [0,1,2,3,4];
+ * }
+ *
+ * hideItems() {
+ * this.items = [];
+ * }
+ *
+ * toggle() {
+ * this.items.length ? this.hideItems() : this.showItems();
+ * }
+ * }
+ * ```
+ *
+ * And now for the animation trigger code:
+ *
+ * ```ts
+ * trigger('listAnimation', [
+ * transition('* => *', [ // each time the binding value changes
+ * query(':leave', [
+ * stagger(100, [
+ * animate('0.5s', style({ opacity: 0 }))
+ * ])
+ * ]),
+ * query(':enter', [
+ * style({ opacity: 0 }),
+ * stagger(100, [
+ * animate('0.5s', style({ opacity: 1 }))
+ * ])
+ * ])
+ * ])
+ * ])
+ * ```
+ *
+ * Now each time the items are added/removed then either the opacity
+ * fade-in animation will run or each removed item will be faded out.
+ * When either of these animations occur then a stagger effect will be
+ * applied after each item's animation is started.
+ *
+ * \@experimental Animation support is experimental.
+ * @param {?} timings
+ * @param {?} animation
+ * @return {?}
+ */
+function stagger(timings, animation) {
+ return { type: 12 /* Stagger */, timings: timings, animation: animation };
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ * @param {?} cb
+ * @return {?}
+ */
+function scheduleMicroTask(cb) {
+ Promise.resolve(null).then(cb);
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * \@experimental Animation support is experimental.
+ */
+var NoopAnimationPlayer = (function () {
+ function NoopAnimationPlayer() {
+ this._onDoneFns = [];
+ this._onStartFns = [];
+ this._onDestroyFns = [];
+ this._started = false;
+ this._destroyed = false;
+ this._finished = false;
+ this.parentPlayer = null;
+ this.totalTime = 0;
+ }
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype._onFinish = function () {
+ if (!this._finished) {
+ this._finished = true;
+ this._onDoneFns.forEach(function (fn) { return fn(); });
+ this._onDoneFns = [];
+ }
+ };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.onStart = function (fn) { this._onStartFns.push(fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.onDone = function (fn) { this._onDoneFns.push(fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.onDestroy = function (fn) { this._onDestroyFns.push(fn); };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.hasStarted = function () { return this._started; };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.init = function () { };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.play = function () {
+ if (!this.hasStarted()) {
+ this.triggerMicrotask();
+ this._onStart();
+ }
+ this._started = true;
+ };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.triggerMicrotask = function () {
+ var _this = this;
+ scheduleMicroTask(function () { return _this._onFinish(); });
+ };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype._onStart = function () {
+ this._onStartFns.forEach(function (fn) { return fn(); });
+ this._onStartFns = [];
+ };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.pause = function () { };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.restart = function () { };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.finish = function () { this._onFinish(); };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.destroy = function () {
+ if (!this._destroyed) {
+ this._destroyed = true;
+ if (!this.hasStarted()) {
+ this._onStart();
+ }
+ this.finish();
+ this._onDestroyFns.forEach(function (fn) { return fn(); });
+ this._onDestroyFns = [];
+ }
+ };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.reset = function () { };
+ /**
+ * @param {?} p
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.setPosition = function (p) { };
+ /**
+ * @return {?}
+ */
+ NoopAnimationPlayer.prototype.getPosition = function () { return 0; };
+ return NoopAnimationPlayer;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var AnimationGroupPlayer = (function () {
+ /**
+ * @param {?} _players
+ */
+ function AnimationGroupPlayer(_players) {
+ var _this = this;
+ this._players = _players;
+ this._onDoneFns = [];
+ this._onStartFns = [];
+ this._finished = false;
+ this._started = false;
+ this._destroyed = false;
+ this._onDestroyFns = [];
+ this.parentPlayer = null;
+ this.totalTime = 0;
+ var doneCount = 0;
+ var destroyCount = 0;
+ var startCount = 0;
+ var total = this._players.length;
+ if (total == 0) {
+ scheduleMicroTask(function () { return _this._onFinish(); });
+ }
+ else {
+ this._players.forEach(function (player) {
+ player.parentPlayer = _this;
+ player.onDone(function () {
+ if (++doneCount >= total) {
+ _this._onFinish();
+ }
+ });
+ player.onDestroy(function () {
+ if (++destroyCount >= total) {
+ _this._onDestroy();
+ }
+ });
+ player.onStart(function () {
+ if (++startCount >= total) {
+ _this._onStart();
+ }
+ });
+ });
+ }
+ this.totalTime = this._players.reduce(function (time, player) { return Math.max(time, player.totalTime); }, 0);
+ }
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype._onFinish = function () {
+ if (!this._finished) {
+ this._finished = true;
+ this._onDoneFns.forEach(function (fn) { return fn(); });
+ this._onDoneFns = [];
+ }
+ };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.init = function () { this._players.forEach(function (player) { return player.init(); }); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.onStart = function (fn) { this._onStartFns.push(fn); };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype._onStart = function () {
+ if (!this.hasStarted()) {
+ this._onStartFns.forEach(function (fn) { return fn(); });
+ this._onStartFns = [];
+ this._started = true;
+ }
+ };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.onDone = function (fn) { this._onDoneFns.push(fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.onDestroy = function (fn) { this._onDestroyFns.push(fn); };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.hasStarted = function () { return this._started; };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.play = function () {
+ if (!this.parentPlayer) {
+ this.init();
+ }
+ this._onStart();
+ this._players.forEach(function (player) { return player.play(); });
+ };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.pause = function () { this._players.forEach(function (player) { return player.pause(); }); };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.restart = function () { this._players.forEach(function (player) { return player.restart(); }); };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.finish = function () {
+ this._onFinish();
+ this._players.forEach(function (player) { return player.finish(); });
+ };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.destroy = function () { this._onDestroy(); };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype._onDestroy = function () {
+ if (!this._destroyed) {
+ this._destroyed = true;
+ this._onFinish();
+ this._players.forEach(function (player) { return player.destroy(); });
+ this._onDestroyFns.forEach(function (fn) { return fn(); });
+ this._onDestroyFns = [];
+ }
+ };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.reset = function () {
+ this._players.forEach(function (player) { return player.reset(); });
+ this._destroyed = false;
+ this._finished = false;
+ this._started = false;
+ };
+ /**
+ * @param {?} p
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.setPosition = function (p) {
+ var /** @type {?} */ timeAtPosition = p * this.totalTime;
+ this._players.forEach(function (player) {
+ var /** @type {?} */ position = player.totalTime ? Math.min(1, timeAtPosition / player.totalTime) : 1;
+ player.setPosition(position);
+ });
+ };
+ /**
+ * @return {?}
+ */
+ AnimationGroupPlayer.prototype.getPosition = function () {
+ var /** @type {?} */ min = 0;
+ this._players.forEach(function (player) {
+ var /** @type {?} */ p = player.getPosition();
+ min = Math.min(p, min);
+ });
+ return min;
+ };
+ Object.defineProperty(AnimationGroupPlayer.prototype, "players", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this._players; },
+ enumerable: true,
+ configurable: true
+ });
+ return AnimationGroupPlayer;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var ɵPRE_STYLE = '!';
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all animation APIs of the animation package.
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the animation package.
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+//# sourceMappingURL=animations.es5.js.map
+
+
+/***/ }),
+/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -350,39 +1673,41 @@ function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(1105));
-__export(__webpack_require__(1106));
+__export(__webpack_require__(136));
+__export(__webpack_require__(232));
/***/ }),
-/* 55 */
+/* 35 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-__webpack_require__(375);
-var Observable_1 = __webpack_require__(1);
-__webpack_require__(178);
-__webpack_require__(65);
-var key_action_1 = __webpack_require__(22);
-var Keymap_1 = __webpack_require__(80);
-var Macro_1 = __webpack_require__(194);
-var UserConfiguration_1 = __webpack_require__(291);
-var Layer_1 = __webpack_require__(454);
-var Module_1 = __webpack_require__(456);
-var actions_1 = __webpack_require__(54);
-var initialState = new UserConfiguration_1.UserConfiguration();
-/* tslint:disable:no-switch-case-fall-through */
-// tslint bug: https://github.com/palantir/tslint/issues/1538
+__webpack_require__(234);
+var Observable_1 = __webpack_require__(0);
+__webpack_require__(54);
+__webpack_require__(21);
+var key_action_1 = __webpack_require__(14);
+var keymap_1 = __webpack_require__(48);
+var macro_1 = __webpack_require__(99);
+var user_configuration_1 = __webpack_require__(137);
+var layer_1 = __webpack_require__(236);
+var module_1 = __webpack_require__(237);
+var actions_1 = __webpack_require__(34);
+var user_config_1 = __webpack_require__(239);
+var initialState = new user_configuration_1.UserConfiguration();
function default_1(state, action) {
if (state === void 0) { state = initialState; }
- var changedUserConfiguration = Object.assign(new UserConfiguration_1.UserConfiguration(), state);
+ var changedUserConfiguration = Object.assign(new user_configuration_1.UserConfiguration(), state);
switch (action.type) {
+ case user_config_1.ActionTypes.LOAD_USER_CONFIG_SUCCESS: {
+ return Object.assign(changedUserConfiguration, action.payload);
+ }
case actions_1.KeymapActions.ADD:
case actions_1.KeymapActions.DUPLICATE:
{
- var newKeymap = new Keymap_1.Keymap(action.payload);
+ var newKeymap = new keymap_1.Keymap(action.payload);
newKeymap.abbreviation = generateAbbr(state.keymaps, newKeymap.abbreviation);
newKeymap.name = generateName(state.keymaps, newKeymap.name);
newKeymap.isDefault = (state.keymaps.length === 0);
@@ -394,7 +1719,7 @@ function default_1(state, action) {
var name_1 = generateName(state.keymaps, action.payload.name);
changedUserConfiguration.keymaps = state.keymaps.map(function (keymap) {
if (keymap.abbreviation === action.payload.abbr) {
- keymap = Object.assign(new Keymap_1.Keymap(), keymap);
+ keymap = Object.assign(new keymap_1.Keymap(), keymap);
keymap.name = name_1;
}
return keymap;
@@ -405,7 +1730,7 @@ function default_1(state, action) {
var abbr_1 = generateAbbr(state.keymaps, action.payload.newAbbr);
changedUserConfiguration.keymaps = state.keymaps.map(function (keymap) {
if (keymap.abbreviation === action.payload.abbr) {
- keymap = Object.assign(new Keymap_1.Keymap(), keymap);
+ keymap = Object.assign(new keymap_1.Keymap(), keymap);
keymap.abbreviation = abbr_1;
}
else {
@@ -417,7 +1742,7 @@ function default_1(state, action) {
case actions_1.KeymapActions.SET_DEFAULT:
changedUserConfiguration.keymaps = state.keymaps.map(function (keymap) {
if (keymap.abbreviation === action.payload || keymap.isDefault) {
- keymap = Object.assign(new Keymap_1.Keymap(), keymap);
+ keymap = Object.assign(new keymap_1.Keymap(), keymap);
keymap.isDefault = keymap.abbreviation === action.payload;
}
return keymap;
@@ -438,20 +1763,20 @@ function default_1(state, action) {
}
// Check for the deleted keymap in other keymaps
changedUserConfiguration.keymaps = filtered.map(function (keymap) {
- keymap = Object.assign(new Keymap_1.Keymap(), keymap);
+ keymap = Object.assign(new keymap_1.Keymap(), keymap);
keymap.layers = checkExistence(keymap.layers, 'keymapAbbreviation', action.payload);
return keymap;
});
break;
case actions_1.KeymapActions.SAVE_KEY:
{
- var newKeymap_1 = Object.assign(new Keymap_1.Keymap(), action.payload.keymap);
+ var newKeymap_1 = Object.assign(new keymap_1.Keymap(), action.payload.keymap);
newKeymap_1.layers = newKeymap_1.layers.slice();
var layerIndex = action.payload.layer;
- var newLayer = Object.assign(new Layer_1.Layer(), newKeymap_1.layers[layerIndex]);
+ var newLayer = Object.assign(new layer_1.Layer(), newKeymap_1.layers[layerIndex]);
newKeymap_1.layers[layerIndex] = newLayer;
var moduleIndex = action.payload.module;
- var newModule = Object.assign(new Module_1.Module(), newLayer.modules[moduleIndex]);
+ var newModule = Object.assign(new module_1.Module(), newLayer.modules[moduleIndex]);
newLayer.modules = newLayer.modules.slice();
newLayer.modules[moduleIndex] = newModule;
var keyIndex = action.payload.key;
@@ -467,14 +1792,14 @@ function default_1(state, action) {
}
case actions_1.KeymapActions.CHECK_MACRO:
changedUserConfiguration.keymaps = state.keymaps.map(function (keymap) {
- keymap = Object.assign(new Keymap_1.Keymap(), keymap);
+ keymap = Object.assign(new keymap_1.Keymap(), keymap);
keymap.layers = checkExistence(keymap.layers, '_macroId', action.payload);
return keymap;
});
break;
case actions_1.MacroActions.ADD:
{
- var newMacro = new Macro_1.Macro();
+ var newMacro = new macro_1.Macro();
newMacro.id = generateMacroId(state.macros);
newMacro.name = generateName(state.macros, 'New macro');
newMacro.isLooped = false;
@@ -485,7 +1810,7 @@ function default_1(state, action) {
}
case actions_1.MacroActions.DUPLICATE:
{
- var newMacro = new Macro_1.Macro(action.payload);
+ var newMacro = new macro_1.Macro(action.payload);
newMacro.name = generateName(state.macros, newMacro.name);
newMacro.id = generateMacroId(state.macros);
changedUserConfiguration.macros = state.macros.concat(newMacro);
@@ -508,7 +1833,7 @@ function default_1(state, action) {
case actions_1.MacroActions.ADD_ACTION:
changedUserConfiguration.macros = state.macros.map(function (macro) {
if (macro.id === action.payload.id) {
- macro = new Macro_1.Macro(macro);
+ macro = new macro_1.Macro(macro);
macro.macroActions.push(action.payload.action);
}
return macro;
@@ -517,7 +1842,7 @@ function default_1(state, action) {
case actions_1.MacroActions.SAVE_ACTION:
changedUserConfiguration.macros = state.macros.map(function (macro) {
if (macro.id === action.payload.id) {
- macro = new Macro_1.Macro(macro);
+ macro = new macro_1.Macro(macro);
macro.macroActions[action.payload.index] = action.payload.action;
}
return macro;
@@ -526,7 +1851,7 @@ function default_1(state, action) {
case actions_1.MacroActions.DELETE_ACTION:
changedUserConfiguration.macros = state.macros.map(function (macro) {
if (macro.id === action.payload.id) {
- macro = new Macro_1.Macro(macro);
+ macro = new macro_1.Macro(macro);
macro.macroActions.splice(action.payload.index, 1);
}
return macro;
@@ -540,7 +1865,7 @@ function default_1(state, action) {
if (newIndex > action.payload.oldIndex) {
--newIndex;
}
- macro = new Macro_1.Macro(macro);
+ macro = new macro_1.Macro(macro);
macro.macroActions.splice(newIndex, 0, macro.macroActions.splice(action.payload.oldIndex, 1)[0]);
}
return macro;
@@ -622,35 +1947,69 @@ function generateMacroId(macros) {
return newId + 1;
}
function checkExistence(layers, property, value) {
- var newLayers = layers.map(function (layer) {
- var newLayer = new Layer_1.Layer(layer);
- newLayer.modules = layer.modules.map(function (module) {
- module.keyActions.forEach(function (action, index) {
+ var keyActionsToClear = [];
+ for (var layerIdx = 0; layerIdx < layers.length; ++layerIdx) {
+ var modules = layers[layerIdx].modules;
+ for (var moduleIdx = 0; moduleIdx < modules.length; ++moduleIdx) {
+ var keyActions = modules[moduleIdx].keyActions;
+ for (var keyActionIdx = 0; keyActionIdx < keyActions.length; ++keyActionIdx) {
+ var action = keyActions[keyActionIdx];
if (action && action.hasOwnProperty(property) && action[property] === value) {
- module.keyActions[index] = undefined;
+ keyActionsToClear.push({
+ layerIdx: layerIdx,
+ moduleIdx: moduleIdx,
+ keyActionIdx: keyActionIdx
+ });
}
- });
- return module;
- });
- return newLayer;
- });
+ }
+ }
+ }
+ if (keyActionsToClear.length === 0) {
+ return layers;
+ }
+ var newLayers = layers.slice();
+ for (var _i = 0, keyActionsToClear_1 = keyActionsToClear; _i < keyActionsToClear_1.length; _i++) {
+ var path = keyActionsToClear_1[_i];
+ if (newLayers[path.layerIdx] === layers[path.layerIdx]) {
+ newLayers[path.layerIdx] = Object.assign(new layer_1.Layer(), newLayers[path.layerIdx]);
+ newLayers[path.layerIdx].modules = newLayers[path.layerIdx].modules.slice();
+ }
+ var newModules = newLayers[path.layerIdx].modules;
+ if (newModules[path.moduleIdx] === layers[path.layerIdx].modules[path.moduleIdx]) {
+ newModules[path.moduleIdx] = Object.assign(new module_1.Module(), newModules[path.moduleIdx]);
+ newModules[path.moduleIdx].keyActions = newModules[path.moduleIdx].keyActions.slice();
+ }
+ newModules[path.moduleIdx].keyActions[path.keyActionIdx] = undefined;
+ }
return newLayers;
}
/***/ }),
-/* 56 */,
-/* 57 */,
-/* 58 */,
-/* 59 */,
-/* 60 */,
-/* 61 */,
-/* 62 */,
-/* 63 */,
-/* 64 */,
-/* 65 */,
-/* 66 */,
-/* 67 */
+/* 36 */,
+/* 37 */,
+/* 38 */,
+/* 39 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(634));
+__export(__webpack_require__(635));
+__export(__webpack_require__(49));
+__export(__webpack_require__(636));
+__export(__webpack_require__(637));
+__export(__webpack_require__(638));
+__export(__webpack_require__(639));
+__export(__webpack_require__(640));
+
+
+/***/ }),
+/* 40 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -665,7 +2024,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
+var core_1 = __webpack_require__(1);
var Tab = (function () {
function Tab() {
this.validAction = new core_1.EventEmitter();
@@ -680,7 +2039,194 @@ exports.Tab = Tab;
/***/ }),
-/* 68 */
+/* 41 */,
+/* 42 */,
+/* 43 */,
+/* 44 */,
+/* 45 */,
+/* 46 */,
+/* 47 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var KeyActionId;
+(function (KeyActionId) {
+ KeyActionId[KeyActionId["NoneAction"] = 0] = "NoneAction";
+ KeyActionId[KeyActionId["KeystrokeAction"] = 1] = "KeystrokeAction";
+ /*
+ 1 - 31 are reserved for KeystrokeAction
+ 5 bits:
+ 1: Do we have scancode?
+ 2: Do we have modifiers?
+ 3: Do we have longpress?
+ 4-5: What kind of keystroke? (basic, short/long media, system)
+ */
+ KeyActionId[KeyActionId["LastKeystrokeAction"] = 31] = "LastKeystrokeAction";
+ KeyActionId[KeyActionId["SwitchLayerAction"] = 32] = "SwitchLayerAction";
+ KeyActionId[KeyActionId["SwitchKeymapAction"] = 33] = "SwitchKeymapAction";
+ KeyActionId[KeyActionId["MouseAction"] = 34] = "MouseAction";
+ KeyActionId[KeyActionId["PlayMacroAction"] = 35] = "PlayMacroAction";
+})(KeyActionId = exports.KeyActionId || (exports.KeyActionId = {}));
+exports.keyActionType = {
+ NoneAction: 'none',
+ KeystrokeAction: 'keystroke',
+ SwitchLayerAction: 'switchLayer',
+ SwitchKeymapAction: 'switchKeymap',
+ MouseAction: 'mouse',
+ PlayMacroAction: 'playMacro'
+};
+var KeyAction = (function () {
+ function KeyAction() {
+ }
+ KeyAction.prototype.assertKeyActionType = function (jsObject) {
+ var keyActionClassname = this.constructor.name;
+ var keyActionTypeString = exports.keyActionType[keyActionClassname];
+ if (jsObject.keyActionType !== keyActionTypeString) {
+ throw "Invalid " + keyActionClassname + ".keyActionType: " + jsObject.keyActionType;
+ }
+ };
+ KeyAction.prototype.readAndAssertKeyActionId = function (buffer) {
+ var classname = this.constructor.name;
+ var readKeyActionId = buffer.readUInt8();
+ var keyActionId = KeyActionId[classname];
+ if (keyActionId === KeyActionId.KeystrokeAction) {
+ if (readKeyActionId < KeyActionId.KeystrokeAction || readKeyActionId > KeyActionId.LastKeystrokeAction) {
+ throw "Invalid " + classname + " first byte: " + readKeyActionId;
+ }
+ }
+ else if (readKeyActionId !== keyActionId) {
+ throw "Invalid " + classname + " first byte: " + readKeyActionId;
+ }
+ return readKeyActionId;
+ };
+ KeyAction.prototype.renameKeymap = function (oldAbbr, newAbbr) {
+ return this;
+ };
+ return KeyAction;
+}());
+exports.KeyAction = KeyAction;
+
+
+/***/ }),
+/* 48 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var layer_1 = __webpack_require__(236);
+var key_action_1 = __webpack_require__(14);
+var Keymap = (function () {
+ function Keymap(keymap) {
+ if (!keymap) {
+ return;
+ }
+ this.name = keymap.name;
+ this.description = keymap.description;
+ this.abbreviation = keymap.abbreviation;
+ this.isDefault = keymap.isDefault;
+ this.layers = keymap.layers.map(function (layer) { return new layer_1.Layer(layer); });
+ }
+ Keymap.prototype.fromJsonObject = function (jsonObject, macros) {
+ this.isDefault = jsonObject.isDefault;
+ this.abbreviation = jsonObject.abbreviation;
+ this.name = jsonObject.name;
+ this.description = jsonObject.description;
+ this.layers = jsonObject.layers.map(function (layer) { return new layer_1.Layer().fromJsonObject(layer, macros); });
+ this.normalize();
+ return this;
+ };
+ Keymap.prototype.fromBinary = function (buffer, macros) {
+ this.abbreviation = buffer.readString();
+ this.isDefault = buffer.readBoolean();
+ this.name = buffer.readString();
+ this.description = buffer.readString();
+ this.layers = buffer.readArray(function (uhkBuffer) {
+ return new layer_1.Layer().fromBinary(uhkBuffer, macros);
+ });
+ this.normalize();
+ return this;
+ };
+ Keymap.prototype.toJsonObject = function (macros) {
+ return {
+ isDefault: this.isDefault,
+ abbreviation: this.abbreviation,
+ name: this.name,
+ description: this.description,
+ layers: this.layers.map(function (layer) { return layer.toJsonObject(macros); })
+ };
+ };
+ Keymap.prototype.toBinary = function (buffer, macros) {
+ buffer.writeString(this.abbreviation);
+ buffer.writeBoolean(this.isDefault);
+ buffer.writeString(this.name);
+ buffer.writeString(this.description);
+ buffer.writeArray(this.layers, function (uhkBuffer, layer) {
+ layer.toBinary(uhkBuffer, macros);
+ });
+ };
+ Keymap.prototype.toString = function () {
+ return "";
+ };
+ Keymap.prototype.renameKeymap = function (oldAbbr, newAbbr) {
+ var _this = this;
+ var layers;
+ var layerModified = false;
+ this.layers.forEach(function (layer, index) {
+ var newLayer = layer.renameKeymap(oldAbbr, newAbbr);
+ if (newLayer !== layer) {
+ if (!layerModified) {
+ layers = _this.layers.slice();
+ layerModified = true;
+ }
+ layers[index] = newLayer;
+ }
+ });
+ if (layerModified) {
+ var newKeymap = Object.assign(new Keymap(), this);
+ newKeymap.layers = layers;
+ return newKeymap;
+ }
+ return this;
+ };
+ Keymap.prototype.normalize = function () {
+ var _this = this;
+ // Removes all the SwitchLayerActions from any non base layer
+ for (var i = 1; i < this.layers.length; ++i) {
+ for (var _i = 0, _a = this.layers[i].modules; _i < _a.length; _i++) {
+ var module_1 = _a[_i];
+ module_1.keyActions = module_1.keyActions.map(function (keyAction) {
+ if (keyAction instanceof key_action_1.SwitchLayerAction) {
+ return undefined;
+ }
+ return keyAction;
+ });
+ }
+ }
+ // Adds the SwitchLayerActions from the base layer to any none base layer
+ var baseLayerModules = this.layers[0].modules;
+ var _loop_1 = function (i) {
+ baseLayerModules[i].keyActions.forEach(function (keyAction, keyActionIndex) {
+ if (keyAction instanceof key_action_1.SwitchLayerAction) {
+ for (var j = 1; j < _this.layers.length; ++j) {
+ _this.layers[j].modules[i].keyActions[keyActionIndex] = new key_action_1.SwitchLayerAction(keyAction);
+ }
+ }
+ });
+ };
+ for (var i = 0; i < baseLayerModules.length; ++i) {
+ _loop_1(i);
+ }
+ };
+ return Keymap;
+}());
+exports.Keymap = Keymap;
+
+
+/***/ }),
+/* 49 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -690,30 +2236,24 @@ var MacroActionId;
(function (MacroActionId) {
MacroActionId[MacroActionId["KeyMacroAction"] = 0] = "KeyMacroAction";
/*
- 0 - 8 are reserved for KeyMacroAction
- PressKeyMacroAction with scancode: 0
- PressKeyMacroAction with modifiers: 1
- PressKeyMacroAction with scancode and modifiers 2
- HoldKeyMacroAction with scancode: 3
- HoldKeyMacroAction with modifiers: 4
- HoldKeyMacroAction with scancode and modifiers 5
- ReleaseKeyMacroAction with scancode: 6
- ReleaseKeyMacroAction with modifiers: 7
- ReleaseKeyMacroAction with scancode and modifiers 8
+ 0 - 63 are reserved for KeyMacroAction
+ 2 bits for: PressKeyMacroAction / HoldKeyMacroAction / ReleaseKeyMacroAction / undefined
+ 2 bits for: with only scancode / only modifiers / both scancode and modifiers / undefined
+ 2 bits for: scancode type basic, short media, long media, system. It should be only used if scancode does exist.
*/
- MacroActionId[MacroActionId["LastKeyMacroAction"] = 8] = "LastKeyMacroAction";
- MacroActionId[MacroActionId["MouseButtonMacroAction"] = 9] = "MouseButtonMacroAction";
+ MacroActionId[MacroActionId["LastKeyMacroAction"] = 63] = "LastKeyMacroAction";
+ MacroActionId[MacroActionId["MouseButtonMacroAction"] = 64] = "MouseButtonMacroAction";
/*
- 9 - 11 are reserved for MouseButtonMacroAction
- PressMouseButtonsMacroAction = 9,
- HoldMouseButtonsMacroAction = 10,
- ReleaseMouseButtonsMacroAction = 11,
+ 64 - 66 are reserved for MouseButtonMacroAction
+ PressMouseButtonsMacroAction = 64,
+ HoldMouseButtonsMacroAction = 65,
+ ReleaseMouseButtonsMacroAction = 66,
*/
- MacroActionId[MacroActionId["LastMouseButtonMacroAction"] = 11] = "LastMouseButtonMacroAction";
- MacroActionId[MacroActionId["MoveMouseMacroAction"] = 12] = "MoveMouseMacroAction";
- MacroActionId[MacroActionId["ScrollMouseMacroAction"] = 13] = "ScrollMouseMacroAction";
- MacroActionId[MacroActionId["DelayMacroAction"] = 14] = "DelayMacroAction";
- MacroActionId[MacroActionId["TextMacroAction"] = 15] = "TextMacroAction";
+ MacroActionId[MacroActionId["LastMouseButtonMacroAction"] = 66] = "LastMouseButtonMacroAction";
+ MacroActionId[MacroActionId["MoveMouseMacroAction"] = 67] = "MoveMouseMacroAction";
+ MacroActionId[MacroActionId["ScrollMouseMacroAction"] = 68] = "ScrollMouseMacroAction";
+ MacroActionId[MacroActionId["DelayMacroAction"] = 69] = "DelayMacroAction";
+ MacroActionId[MacroActionId["TextMacroAction"] = 70] = "TextMacroAction";
})(MacroActionId = exports.MacroActionId || (exports.MacroActionId = {}));
var MacroSubAction;
(function (MacroSubAction) {
@@ -765,39 +2305,31 @@ exports.MacroAction = MacroAction;
/***/ }),
-/* 69 */
+/* 50 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(457));
-__export(__webpack_require__(1100));
-__export(__webpack_require__(458));
-__export(__webpack_require__(68));
-__export(__webpack_require__(460));
-__export(__webpack_require__(459));
-__export(__webpack_require__(461));
-__export(__webpack_require__(462));
-__export(__webpack_require__(1101));
-
-
-/***/ }),
-/* 70 */,
-/* 71 */,
-/* 72 */,
-/* 73 */,
-/* 74 */,
-/* 75 */,
-/* 76 */,
-/* 77 */,
-/* 78 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
@@ -807,6 +2339,10 @@ __export(__webpack_require__(1101));
/**/
+var processNextTick = __webpack_require__(101);
+/**/
+
+/**/
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) {
@@ -818,16 +2354,12 @@ var objectKeys = Object.keys || function (obj) {
module.exports = Duplex;
/**/
-var processNextTick = __webpack_require__(268);
+var util = __webpack_require__(76);
+util.inherits = __webpack_require__(58);
/**/
-/**/
-var util = __webpack_require__(120);
-util.inherits = __webpack_require__(92);
-/**/
-
-var Readable = __webpack_require__(408);
-var Writable = __webpack_require__(271);
+var Readable = __webpack_require__(251);
+var Writable = __webpack_require__(150);
util.inherits(Duplex, Readable);
@@ -868,6 +2400,34 @@ function onEndNT(self) {
self.end();
}
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed && this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ this._writableState.destroyed = value;
+ }
+});
+
+Duplex.prototype._destroy = function (err, cb) {
+ this.push(null);
+ this.end();
+
+ processNextTick(cb, err);
+};
+
function forEach(xs, f) {
for (var i = 0, l = xs.length; i < l; i++) {
f(xs[i], i);
@@ -875,167 +2435,59 @@ function forEach(xs, f) {
}
/***/ }),
-/* 79 */,
-/* 80 */
+/* 51 */,
+/* 52 */,
+/* 53 */,
+/* 54 */,
+/* 55 */,
+/* 56 */,
+/* 57 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var Layer_1 = __webpack_require__(454);
-var Keymap = (function () {
- function Keymap(keymap) {
- if (!keymap) {
- return;
- }
- this.name = keymap.name;
- this.description = keymap.description;
- this.abbreviation = keymap.abbreviation;
- this.isDefault = keymap.isDefault;
- this.layers = keymap.layers.map(function (layer) { return new Layer_1.Layer(layer); });
+var constants_1 = __webpack_require__(642);
+exports.Constants = constants_1.Constants;
+// Source: http://stackoverflow.com/questions/13720256/javascript-regex-camelcase-to-sentence
+function camelCaseToSentence(camelCasedText) {
+ return camelCasedText.replace(/^[a-z]|[A-Z]/g, function (v, i) {
+ return i === 0 ? v.toUpperCase() : ' ' + v.toLowerCase();
+ });
+}
+exports.camelCaseToSentence = camelCaseToSentence;
+function capitalizeFirstLetter(text) {
+ return text.charAt(0).toUpperCase() + text.slice(1);
+}
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+/**
+ * This function coerces a string into a string literal type.
+ * Using tagged union types in TypeScript 2.0, this enables
+ * powerful typechecking of our reducers.
+ *
+ * Since every action label passes through this function it
+ * is a good place to ensure all of our action labels
+ * are unique.
+ */
+var typeCache = {};
+function type(label) {
+ if (typeCache[label]) {
+ throw new Error("Action type \"" + label + "\" is not unique\"");
}
- Keymap.prototype.fromJsonObject = function (jsonObject, macros) {
- this.isDefault = jsonObject.isDefault;
- this.abbreviation = jsonObject.abbreviation;
- this.name = jsonObject.name;
- this.description = jsonObject.description;
- this.layers = jsonObject.layers.map(function (layer) { return new Layer_1.Layer().fromJsonObject(layer, macros); });
- return this;
- };
- Keymap.prototype.fromBinary = function (buffer, macros) {
- this.abbreviation = buffer.readString();
- this.isDefault = buffer.readBoolean();
- this.name = buffer.readString();
- this.description = buffer.readString();
- this.layers = buffer.readArray(function (uhkBuffer) {
- return new Layer_1.Layer().fromBinary(uhkBuffer, macros);
- });
- return this;
- };
- Keymap.prototype.toJsonObject = function (macros) {
- return {
- isDefault: this.isDefault,
- abbreviation: this.abbreviation,
- name: this.name,
- description: this.description,
- layers: this.layers.map(function (layer) { return layer.toJsonObject(macros); })
- };
- };
- Keymap.prototype.toBinary = function (buffer, macros) {
- buffer.writeString(this.abbreviation);
- buffer.writeBoolean(this.isDefault);
- buffer.writeString(this.name);
- buffer.writeString(this.description);
- buffer.writeArray(this.layers, function (uhkBuffer, layer) {
- layer.toBinary(uhkBuffer, macros);
- });
- };
- Keymap.prototype.toString = function () {
- return "";
- };
- Keymap.prototype.renameKeymap = function (oldAbbr, newAbbr) {
- var _this = this;
- var layers;
- var layerModified = false;
- this.layers.forEach(function (layer, index) {
- var newLayer = layer.renameKeymap(oldAbbr, newAbbr);
- if (newLayer !== layer) {
- if (!layerModified) {
- layers = _this.layers.slice();
- layerModified = true;
- }
- layers[index] = newLayer;
- }
- });
- if (layerModified) {
- var newKeymap = Object.assign(new Keymap(), this);
- newKeymap.layers = layers;
- return newKeymap;
- }
- return this;
- };
- return Keymap;
-}());
-exports.Keymap = Keymap;
+ typeCache[label] = true;
+ return label;
+}
+exports.type = type;
+var ipcEvents_1 = __webpack_require__(643);
+exports.IpcEvents = ipcEvents_1.IpcEvents;
+function runInElectron() {
+ return window && window.process && window.process.type;
+}
+exports.runInElectron = runInElectron;
/***/ }),
-/* 81 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-///
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var KeyActionId;
-(function (KeyActionId) {
- KeyActionId[KeyActionId["NoneAction"] = 0] = "NoneAction";
- KeyActionId[KeyActionId["KeystrokeAction"] = 1] = "KeystrokeAction";
- /*
- 1 - 7 are reserved for KeystrokeAction
- 3 bits:
- 1: Do we have scancode?
- 2: Do we have modifiers?
- 3: Do we have longpress?
- */
- KeyActionId[KeyActionId["LastKeystrokeAction"] = 7] = "LastKeystrokeAction";
- KeyActionId[KeyActionId["SwitchLayerAction"] = 8] = "SwitchLayerAction";
- KeyActionId[KeyActionId["SwitchKeymapAction"] = 9] = "SwitchKeymapAction";
- KeyActionId[KeyActionId["MouseAction"] = 10] = "MouseAction";
- KeyActionId[KeyActionId["PlayMacroAction"] = 11] = "PlayMacroAction";
-})(KeyActionId = exports.KeyActionId || (exports.KeyActionId = {}));
-exports.keyActionType = {
- NoneAction: 'none',
- KeystrokeAction: 'keystroke',
- SwitchLayerAction: 'switchLayer',
- SwitchKeymapAction: 'switchKeymap',
- MouseAction: 'mouse',
- PlayMacroAction: 'playMacro'
-};
-var KeyAction = (function () {
- function KeyAction() {
- }
- KeyAction.prototype.assertKeyActionType = function (jsObject) {
- var keyActionClassname = this.constructor.name;
- var keyActionTypeString = exports.keyActionType[keyActionClassname];
- if (jsObject.keyActionType !== keyActionTypeString) {
- throw "Invalid " + keyActionClassname + ".keyActionType: " + jsObject.keyActionType;
- }
- };
- KeyAction.prototype.readAndAssertKeyActionId = function (buffer) {
- var classname = this.constructor.name;
- var readKeyActionId = buffer.readUInt8();
- var keyActionId = KeyActionId[classname];
- if (keyActionId === KeyActionId.KeystrokeAction) {
- if (readKeyActionId < KeyActionId.KeystrokeAction || readKeyActionId > KeyActionId.LastKeystrokeAction) {
- throw "Invalid " + classname + " first byte: " + readKeyActionId;
- }
- }
- else if (readKeyActionId !== keyActionId) {
- throw "Invalid " + classname + " first byte: " + readKeyActionId;
- }
- return readKeyActionId;
- };
- KeyAction.prototype.renameKeymap = function (oldAbbr, newAbbr) {
- return this;
- };
- return KeyAction;
-}());
-exports.KeyAction = KeyAction;
-
-
-/***/ }),
-/* 82 */,
-/* 83 */,
-/* 84 */,
-/* 85 */,
-/* 86 */,
-/* 87 */,
-/* 88 */,
-/* 89 */,
-/* 90 */,
-/* 91 */,
-/* 92 */
+/* 58 */
/***/ (function(module, exports) {
if (typeof Object.create === 'function') {
@@ -1064,34 +2516,24 @@ if (typeof Object.create === 'function') {
/***/ }),
-/* 93 */,
-/* 94 */,
-/* 95 */,
-/* 96 */,
-/* 97 */,
-/* 98 */,
-/* 99 */,
-/* 100 */,
-/* 101 */,
-/* 102 */,
-/* 103 */,
-/* 104 */,
-/* 105 */,
-/* 106 */,
-/* 107 */,
-/* 108 */,
-/* 109 */,
-/* 110 */,
-/* 111 */,
-/* 112 */,
-/* 113 */,
-/* 114 */,
-/* 115 */,
-/* 116 */,
-/* 117 */,
-/* 118 */,
-/* 119 */,
-/* 120 */
+/* 59 */,
+/* 60 */,
+/* 61 */,
+/* 62 */,
+/* 63 */,
+/* 64 */,
+/* 65 */,
+/* 66 */,
+/* 67 */,
+/* 68 */,
+/* 69 */,
+/* 70 */,
+/* 71 */,
+/* 72 */,
+/* 73 */,
+/* 74 */,
+/* 75 */,
+/* 76 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(Buffer) {// Copyright Joyent, Inc. and other Node contributors.
@@ -1202,9 +2644,214 @@ function objectToString(o) {
return Object.prototype.toString.call(o);
}
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56).Buffer))
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(75).Buffer))
/***/ }),
+/* 77 */,
+/* 78 */,
+/* 79 */,
+/* 80 */,
+/* 81 */,
+/* 82 */,
+/* 83 */,
+/* 84 */,
+/* 85 */,
+/* 86 */,
+/* 87 */,
+/* 88 */,
+/* 89 */,
+/* 90 */,
+/* 91 */,
+/* 92 */,
+/* 93 */,
+/* 94 */,
+/* 95 */,
+/* 96 */,
+/* 97 */,
+/* 98 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var KeystrokeType;
+(function (KeystrokeType) {
+ KeystrokeType[KeystrokeType["basic"] = 0] = "basic";
+ KeystrokeType[KeystrokeType["shortMedia"] = 1] = "shortMedia";
+ KeystrokeType[KeystrokeType["longMedia"] = 2] = "longMedia";
+ KeystrokeType[KeystrokeType["system"] = 3] = "system";
+})(KeystrokeType = exports.KeystrokeType || (exports.KeystrokeType = {}));
+
+
+/***/ }),
+/* 99 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var assert_1 = __webpack_require__(17);
+var macro_action_1 = __webpack_require__(39);
+var Macro = (function () {
+ function Macro(other) {
+ if (!other) {
+ return;
+ }
+ this.id = other.id;
+ this.isLooped = other.isLooped;
+ this.isPrivate = other.isPrivate;
+ this.name = other.name;
+ this.macroActions = other.macroActions.map(function (macroAction) { return macro_action_1.Helper.createMacroAction(macroAction); });
+ }
+ Macro.prototype.fromJsonObject = function (jsonObject) {
+ this.isLooped = jsonObject.isLooped;
+ this.isPrivate = jsonObject.isPrivate;
+ this.name = jsonObject.name;
+ this.macroActions = jsonObject.macroActions.map(function (macroAction) { return macro_action_1.Helper.createMacroAction(macroAction); });
+ return this;
+ };
+ Macro.prototype.fromBinary = function (buffer) {
+ this.isLooped = buffer.readBoolean();
+ this.isPrivate = buffer.readBoolean();
+ this.name = buffer.readString();
+ var macroActionsLength = buffer.readCompactLength();
+ this.macroActions = [];
+ for (var i = 0; i < macroActionsLength; ++i) {
+ this.macroActions.push(macro_action_1.Helper.createMacroAction(buffer));
+ }
+ return this;
+ };
+ Macro.prototype.toJsonObject = function () {
+ return {
+ isLooped: this.isLooped,
+ isPrivate: this.isPrivate,
+ name: this.name,
+ macroActions: this.macroActions.map(function (macroAction) { return macroAction.toJsonObject(); })
+ };
+ };
+ Macro.prototype.toBinary = function (buffer) {
+ buffer.writeBoolean(this.isLooped);
+ buffer.writeBoolean(this.isPrivate);
+ buffer.writeString(this.name);
+ buffer.writeArray(this.macroActions);
+ };
+ Macro.prototype.toString = function () {
+ return "";
+ };
+ return Macro;
+}());
+__decorate([
+ assert_1.assertUInt8,
+ __metadata("design:type", Number)
+], Macro.prototype, "id", void 0);
+exports.Macro = Macro;
+
+
+/***/ }),
+/* 100 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(40));
+var keymap_1 = __webpack_require__(678);
+exports.KeymapTabComponent = keymap_1.KeymapTabComponent;
+var keypress_1 = __webpack_require__(682);
+exports.KeypressTabComponent = keypress_1.KeypressTabComponent;
+var layer_1 = __webpack_require__(688);
+exports.LayerTabComponent = layer_1.LayerTabComponent;
+var macro_1 = __webpack_require__(692);
+exports.MacroTabComponent = macro_1.MacroTabComponent;
+var mouse_1 = __webpack_require__(696);
+exports.MouseTabComponent = mouse_1.MouseTabComponent;
+var none_1 = __webpack_require__(700);
+exports.NoneTabComponent = none_1.NoneTabComponent;
+
+
+/***/ }),
+/* 101 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {
+
+if (!process.version ||
+ process.version.indexOf('v0.') === 0 ||
+ process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+ module.exports = nextTick;
+} else {
+ module.exports = process.nextTick;
+}
+
+function nextTick(fn, arg1, arg2, arg3) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('"callback" argument must be a function');
+ }
+ var len = arguments.length;
+ var args, i;
+ switch (len) {
+ case 0:
+ case 1:
+ return process.nextTick(fn);
+ case 2:
+ return process.nextTick(function afterTickOne() {
+ fn.call(null, arg1);
+ });
+ case 3:
+ return process.nextTick(function afterTickTwo() {
+ fn.call(null, arg1, arg2);
+ });
+ case 4:
+ return process.nextTick(function afterTickThree() {
+ fn.call(null, arg1, arg2, arg3);
+ });
+ default:
+ args = new Array(len - 1);
+ i = 0;
+ while (i < args.length) {
+ args[i++] = arguments[i];
+ }
+ return process.nextTick(function afterTick() {
+ fn.apply(null, args);
+ });
+ }
+}
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(38)))
+
+/***/ }),
+/* 102 */,
+/* 103 */,
+/* 104 */,
+/* 105 */,
+/* 106 */,
+/* 107 */,
+/* 108 */,
+/* 109 */,
+/* 110 */,
+/* 111 */,
+/* 112 */,
+/* 113 */,
+/* 114 */,
+/* 115 */,
+/* 116 */,
+/* 117 */,
+/* 118 */,
+/* 119 */,
+/* 120 */,
/* 121 */,
/* 122 */,
/* 123 */,
@@ -1214,52 +2861,794 @@ function objectToString(o) {
/* 127 */,
/* 128 */,
/* 129 */,
-/* 130 */,
-/* 131 */,
-/* 132 */,
-/* 133 */,
-/* 134 */,
-/* 135 */,
-/* 136 */,
-/* 137 */,
-/* 138 */,
-/* 139 */,
-/* 140 */,
-/* 141 */,
-/* 142 */,
-/* 143 */,
-/* 144 */,
-/* 145 */,
-/* 146 */,
-/* 147 */,
-/* 148 */,
-/* 149 */,
-/* 150 */,
-/* 151 */,
-/* 152 */,
-/* 153 */,
-/* 154 */,
-/* 155 */,
-/* 156 */,
-/* 157 */,
-/* 158 */,
-/* 159 */,
-/* 160 */,
-/* 161 */,
-/* 162 */,
-/* 163 */,
-/* 164 */,
-/* 165 */,
-/* 166 */,
-/* 167 */,
-/* 168 */,
-/* 169 */,
-/* 170 */,
-/* 171 */,
-/* 172 */,
-/* 173 */,
-/* 174 */,
-/* 175 */
+/* 130 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__src_instrument__ = __webpack_require__(595);
+/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "StoreDevtoolsModule", function() { return __WEBPACK_IMPORTED_MODULE_0__src_instrument__["a"]; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__src_devtools__ = __webpack_require__(222);
+/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "StoreDevtools", function() { return __WEBPACK_IMPORTED_MODULE_1__src_devtools__["b"]; });
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+/* 131 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (immutable) */ __webpack_exports__["b"] = difference;
+/* harmony export (immutable) */ __webpack_exports__["d"] = unliftState;
+/* unused harmony export unliftAction */
+/* harmony export (immutable) */ __webpack_exports__["c"] = liftAction;
+/* harmony export (immutable) */ __webpack_exports__["a"] = applyOperators;
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__actions__ = __webpack_require__(132);
+
+function difference(first, second) {
+ return first.filter(function (item) { return second.indexOf(item) < 0; });
+}
+/**
+ * Provides an app's view into the state of the lifted store.
+ */
+function unliftState(liftedState) {
+ var computedStates = liftedState.computedStates, currentStateIndex = liftedState.currentStateIndex;
+ var state = computedStates[currentStateIndex].state;
+ return state;
+}
+function unliftAction(liftedState) {
+ return liftedState.actionsById[liftedState.nextActionId - 1];
+}
+/**
+* Lifts an app's action into an action on the lifted store.
+*/
+function liftAction(action) {
+ return __WEBPACK_IMPORTED_MODULE_0__actions__["b" /* StoreDevtoolActions */].performAction(action);
+}
+function applyOperators(input$, operators) {
+ return operators.reduce(function (source$, _a) {
+ var operator = _a[0], args = _a.slice(1);
+ return operator.apply(source$, args);
+ }, input$);
+}
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+/* 132 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ActionTypes; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return StoreDevtoolActions; });
+var ActionTypes = {
+ PERFORM_ACTION: 'PERFORM_ACTION',
+ RESET: 'RESET',
+ ROLLBACK: 'ROLLBACK',
+ COMMIT: 'COMMIT',
+ SWEEP: 'SWEEP',
+ TOGGLE_ACTION: 'TOGGLE_ACTION',
+ SET_ACTIONS_ACTIVE: 'SET_ACTIONS_ACTIVE',
+ JUMP_TO_STATE: 'JUMP_TO_STATE',
+ IMPORT_STATE: 'IMPORT_STATE'
+};
+/**
+* Action creators to change the History state.
+*/
+var StoreDevtoolActions = {
+ performAction: function (action) {
+ if (typeof action.type === 'undefined') {
+ throw new Error('Actions may not have an undefined "type" property. ' +
+ 'Have you misspelled a constant?');
+ }
+ return { type: ActionTypes.PERFORM_ACTION, action: action, timestamp: Date.now() };
+ },
+ reset: function () {
+ return { type: ActionTypes.RESET, timestamp: Date.now() };
+ },
+ rollback: function () {
+ return { type: ActionTypes.ROLLBACK, timestamp: Date.now() };
+ },
+ commit: function () {
+ return { type: ActionTypes.COMMIT, timestamp: Date.now() };
+ },
+ sweep: function () {
+ return { type: ActionTypes.SWEEP };
+ },
+ toggleAction: function (id) {
+ return { type: ActionTypes.TOGGLE_ACTION, id: id };
+ },
+ setActionsActive: function (start, end, active) {
+ if (active === void 0) { active = true; }
+ return { type: ActionTypes.SET_ACTIONS_ACTIVE, start: start, end: end, active: active };
+ },
+ jumpToState: function (index) {
+ return { type: ActionTypes.JUMP_TO_STATE, index: index };
+ },
+ importState: function (nextLiftedState) {
+ return { type: ActionTypes.IMPORT_STATE, nextLiftedState: nextLiftedState };
+ }
+};
+//# sourceMappingURL=actions.js.map
+
+/***/ }),
+/* 133 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var pluck_1 = __webpack_require__(124);
+var map_1 = __webpack_require__(16);
+var distinctUntilChanged_1 = __webpack_require__(94);
+function select(pathOrMapFn) {
+ var paths = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ paths[_i - 1] = arguments[_i];
+ }
+ var mapped$;
+ if (typeof pathOrMapFn === 'string') {
+ mapped$ = pluck_1.pluck.call.apply(pluck_1.pluck, [this, pathOrMapFn].concat(paths));
+ }
+ else if (typeof pathOrMapFn === 'function') {
+ mapped$ = map_1.map.call(this, pathOrMapFn);
+ }
+ else {
+ throw new TypeError(("Unexpected type " + typeof pathOrMapFn + " in select operator,")
+ + " expected 'string' or 'function'");
+ }
+ return distinctUntilChanged_1.distinctUntilChanged.call(mapped$);
+}
+exports.select = select;
+
+
+/***/ }),
+/* 134 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DockActions; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+
+var DockActions = (function () {
+ function DockActions() {
+ }
+ DockActions.prototype.toggleVisibility = function () {
+ return { type: DockActions.TOGGLE_VISIBILITY };
+ };
+ DockActions.prototype.changePosition = function () {
+ return { type: DockActions.CHANGE_POSITION };
+ };
+ DockActions.prototype.changeSize = function (size) {
+ return { type: DockActions.CHANGE_SIZE, payload: size };
+ };
+ DockActions.prototype.changeMonitor = function () {
+ return { type: DockActions.CHANGE_MONITOR };
+ };
+ DockActions.TOGGLE_VISIBILITY = '@@redux-devtools-log-monitor/TOGGLE_VISIBILITY';
+ DockActions.CHANGE_POSITION = '@@redux-devtools-log-monitor/CHANGE_POSITION';
+ DockActions.CHANGE_SIZE = '@@redux-devtools-log-monitor/CHANGE_SIZE';
+ DockActions.CHANGE_MONITOR = '@@redux-devtools-log-monitor/CHANGE_MONITOR';
+ DockActions.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
+ ];
+ /** @nocollapse */
+ DockActions.ctorParameters = [];
+ return DockActions;
+}());
+//# sourceMappingURL=actions.js.map
+
+/***/ }),
+/* 135 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return routerActions; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return routerActionTypes; });
+/* harmony export (immutable) */ __webpack_exports__["c"] = go;
+/* harmony export (immutable) */ __webpack_exports__["d"] = replace;
+/* harmony export (immutable) */ __webpack_exports__["g"] = search;
+/* harmony export (immutable) */ __webpack_exports__["h"] = show;
+/* harmony export (immutable) */ __webpack_exports__["a"] = back;
+/* harmony export (immutable) */ __webpack_exports__["b"] = forward;
+var routerActions = {
+ GO: '[Router] Go',
+ REPLACE: '[Router] Replace',
+ SEARCH: '[Router] Search',
+ SHOW: '[Router] Show',
+ BACK: '[Router] Back',
+ FORWARD: '[Router] Forward',
+ UPDATE_LOCATION: '[Router] Update Location'
+};
+var routerActionTypes = Object.keys(routerActions).map(function (key) { return routerActions[key]; });
+function go(path, query, extras) {
+ var payload = { path: path, query: query, extras: extras };
+ return { type: routerActions.GO, payload: payload };
+}
+function replace(path, query, extras) {
+ var payload = { path: path, query: query, extras: extras };
+ return { type: routerActions.REPLACE, payload: payload };
+}
+function search(query, extras) {
+ var payload = { query: query, extras: extras };
+ return { type: routerActions.SEARCH, payload: payload };
+}
+function show(path, query, extras) {
+ var payload = { path: path, query: query, extras: extras };
+ return { type: routerActions.SHOW, payload: payload };
+}
+function back() {
+ var payload = {};
+ return { type: routerActions.BACK, payload: payload };
+}
+function forward() {
+ var payload = {};
+ return { type: routerActions.FORWARD, payload: payload };
+}
+//# sourceMappingURL=actions.js.map
+
+/***/ }),
+/* 136 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var KeymapActions;
+(function (KeymapActions) {
+ KeymapActions.PREFIX = '[Keymap] ';
+ KeymapActions.ADD = KeymapActions.PREFIX + 'Add keymap';
+ KeymapActions.DUPLICATE = KeymapActions.PREFIX + 'Duplicate keymap';
+ KeymapActions.EDIT_ABBR = KeymapActions.PREFIX + 'Edit keymap abbreviation';
+ KeymapActions.EDIT_NAME = KeymapActions.PREFIX + 'Edit keymap title';
+ KeymapActions.SAVE_KEY = KeymapActions.PREFIX + 'Save key action';
+ KeymapActions.SET_DEFAULT = KeymapActions.PREFIX + 'Set default option';
+ KeymapActions.REMOVE = KeymapActions.PREFIX + 'Remove keymap';
+ KeymapActions.CHECK_MACRO = KeymapActions.PREFIX + 'Check deleted macro';
+ KeymapActions.LOAD_KEYMAPS = KeymapActions.PREFIX + 'Load keymaps';
+ KeymapActions.LOAD_KEYMAPS_SUCCESS = KeymapActions.PREFIX + 'Load keymaps success';
+ function loadKeymaps() {
+ return {
+ type: KeymapActions.LOAD_KEYMAPS
+ };
+ }
+ KeymapActions.loadKeymaps = loadKeymaps;
+ function loadKeymapsSuccess(keymaps) {
+ return {
+ type: KeymapActions.LOAD_KEYMAPS_SUCCESS,
+ payload: keymaps
+ };
+ }
+ KeymapActions.loadKeymapsSuccess = loadKeymapsSuccess;
+ function addKeymap(item) {
+ return {
+ type: KeymapActions.ADD,
+ payload: item
+ };
+ }
+ KeymapActions.addKeymap = addKeymap;
+ function setDefault(abbr) {
+ return {
+ type: KeymapActions.SET_DEFAULT,
+ payload: abbr
+ };
+ }
+ KeymapActions.setDefault = setDefault;
+ function removeKeymap(abbr) {
+ return {
+ type: KeymapActions.REMOVE,
+ payload: abbr
+ };
+ }
+ KeymapActions.removeKeymap = removeKeymap;
+ function duplicateKeymap(keymap) {
+ return {
+ type: KeymapActions.DUPLICATE,
+ payload: keymap
+ };
+ }
+ KeymapActions.duplicateKeymap = duplicateKeymap;
+ function editKeymapName(abbr, name) {
+ return {
+ type: KeymapActions.EDIT_NAME,
+ payload: {
+ abbr: abbr,
+ name: name
+ }
+ };
+ }
+ KeymapActions.editKeymapName = editKeymapName;
+ function editKeymapAbbr(abbr, newAbbr) {
+ return {
+ type: KeymapActions.EDIT_ABBR,
+ payload: {
+ abbr: abbr,
+ newAbbr: newAbbr
+ }
+ };
+ }
+ KeymapActions.editKeymapAbbr = editKeymapAbbr;
+ function saveKey(keymap, layer, module, key, keyAction) {
+ return {
+ type: KeymapActions.SAVE_KEY,
+ payload: {
+ keymap: keymap,
+ layer: layer,
+ module: module,
+ key: key,
+ keyAction: keyAction
+ }
+ };
+ }
+ KeymapActions.saveKey = saveKey;
+ function checkMacro(macro) {
+ return {
+ type: KeymapActions.CHECK_MACRO,
+ payload: macro
+ };
+ }
+ KeymapActions.checkMacro = checkMacro;
+})(KeymapActions = exports.KeymapActions || (exports.KeymapActions = {}));
+
+
+/***/ }),
+/* 137 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var assert_1 = __webpack_require__(17);
+var keymap_1 = __webpack_require__(48);
+var macro_1 = __webpack_require__(99);
+var module_configuration_1 = __webpack_require__(641);
+var UserConfiguration = (function () {
+ function UserConfiguration() {
+ this.moduleConfigurations = [];
+ this.keymaps = [];
+ this.macros = [];
+ }
+ UserConfiguration.prototype.fromJsonObject = function (jsonObject) {
+ var _this = this;
+ this.dataModelVersion = jsonObject.dataModelVersion;
+ this.moduleConfigurations = jsonObject.moduleConfigurations.map(function (moduleConfiguration) {
+ return new module_configuration_1.ModuleConfiguration().fromJsonObject(moduleConfiguration);
+ });
+ this.macros = jsonObject.macros.map(function (macroJsonObject, index) {
+ var macro = new macro_1.Macro().fromJsonObject(macroJsonObject);
+ macro.id = index;
+ return macro;
+ });
+ this.keymaps = jsonObject.keymaps.map(function (keymap) { return new keymap_1.Keymap().fromJsonObject(keymap, _this.macros); });
+ return this;
+ };
+ UserConfiguration.prototype.fromBinary = function (buffer) {
+ var _this = this;
+ this.dataModelVersion = buffer.readUInt16();
+ this.moduleConfigurations = buffer.readArray(function (uhkBuffer) {
+ return new module_configuration_1.ModuleConfiguration().fromBinary(uhkBuffer);
+ });
+ this.macros = buffer.readArray(function (uhkBuffer, index) {
+ var macro = new macro_1.Macro().fromBinary(uhkBuffer);
+ macro.id = index;
+ return macro;
+ });
+ this.keymaps = buffer.readArray(function (uhkBuffer) { return new keymap_1.Keymap().fromBinary(uhkBuffer, _this.macros); });
+ return this;
+ };
+ UserConfiguration.prototype.toJsonObject = function () {
+ var _this = this;
+ return {
+ dataModelVersion: this.dataModelVersion,
+ moduleConfigurations: this.moduleConfigurations.map(function (moduleConfiguration) { return moduleConfiguration.toJsonObject(); }),
+ keymaps: this.keymaps.map(function (keymap) { return keymap.toJsonObject(_this.macros); }),
+ macros: this.macros.map(function (macro) { return macro.toJsonObject(); })
+ };
+ };
+ UserConfiguration.prototype.toBinary = function (buffer) {
+ var _this = this;
+ buffer.writeUInt16(this.dataModelVersion);
+ buffer.writeArray(this.moduleConfigurations);
+ buffer.writeArray(this.macros);
+ buffer.writeArray(this.keymaps, function (uhkBuffer, keymap) {
+ keymap.toBinary(uhkBuffer, _this.macros);
+ });
+ };
+ UserConfiguration.prototype.toString = function () {
+ return "";
+ };
+ UserConfiguration.prototype.getKeymap = function (keymapAbbreviation) {
+ return this.keymaps.find(function (keymap) { return keymapAbbreviation === keymap.abbreviation; });
+ };
+ UserConfiguration.prototype.getMacro = function (macroId) {
+ return this.macros.find(function (macro) { return macroId === macro.id; });
+ };
+ return UserConfiguration;
+}());
+__decorate([
+ assert_1.assertUInt16,
+ __metadata("design:type", Number)
+], UserConfiguration.prototype, "dataModelVersion", void 0);
+exports.UserConfiguration = UserConfiguration;
+
+
+/***/ }),
+/* 138 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(240));
+__export(__webpack_require__(655));
+__export(__webpack_require__(658));
+__export(__webpack_require__(661));
+__export(__webpack_require__(139));
+__export(__webpack_require__(666));
+__export(__webpack_require__(670));
+__export(__webpack_require__(241));
+
+
+/***/ }),
+/* 139 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var macro_not_found_component_1 = __webpack_require__(662);
+exports.MacroNotFoundComponent = macro_not_found_component_1.MacroNotFoundComponent;
+var macro_not_found_guard_service_1 = __webpack_require__(665);
+exports.MacroNotFoundGuard = macro_not_found_guard_service_1.MacroNotFoundGuard;
+
+
+/***/ }),
+/* 140 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var KeyModifiers;
+(function (KeyModifiers) {
+ KeyModifiers[KeyModifiers["leftCtrl"] = 1] = "leftCtrl";
+ KeyModifiers[KeyModifiers["leftShift"] = 2] = "leftShift";
+ KeyModifiers[KeyModifiers["leftAlt"] = 4] = "leftAlt";
+ KeyModifiers[KeyModifiers["leftGui"] = 8] = "leftGui";
+ KeyModifiers[KeyModifiers["rightCtrl"] = 16] = "rightCtrl";
+ KeyModifiers[KeyModifiers["rightShift"] = 32] = "rightShift";
+ KeyModifiers[KeyModifiers["rightAlt"] = 64] = "rightAlt";
+ KeyModifiers[KeyModifiers["rightGui"] = 128] = "rightGui";
+})(KeyModifiers = exports.KeyModifiers || (exports.KeyModifiers = {}));
+
+
+/***/ }),
+/* 141 */
+/***/ (function(module, exports) {
+
+module.exports = ":host {\n display: block;\n width: 100%; }\n\n.action--editor {\n padding-top: 0;\n padding-bottom: 0;\n border-radius: 0;\n border: 0; }\n\n.nav {\n padding-bottom: 1rem; }\n .nav li a {\n border-top-right-radius: 0;\n border-bottom-right-radius: 0; }\n .nav li a.selected {\n font-style: italic; }\n .nav li a:hover {\n cursor: pointer; }\n .nav li.active {\n z-index: 2; }\n .nav li.active a.selected {\n font-style: normal; }\n .nav li.active a:after {\n content: '';\n display: block;\n position: absolute;\n width: 0;\n height: 0;\n top: 0;\n right: -4rem;\n border-color: transparent transparent transparent #337ab7;\n border-style: solid;\n border-width: 2rem; }\n\n.editor__tabs, .editor__tab-links {\n padding-top: 1rem; }\n\n.editor__tabs {\n border-left: 1px solid #ddd;\n margin-left: -1.6rem;\n padding-left: 3rem; }\n\n.editor__actions {\n float: right; }\n .editor__actions-container {\n background: #f5f5f5;\n border-top: 1px solid #ddd;\n border-bottom: 1px solid #ddd;\n padding: 1rem 1.5rem; }\n\n.flex-button-wrapper {\n display: flex;\n flex-direction: row-reverse; }\n\n.flex-button {\n align-self: flex-end; }\n"
+
+/***/ }),
+/* 142 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var CaptureService = (function () {
+ function CaptureService() {
+ this.leftModifiers = new Map();
+ this.rightModifiers = new Map();
+ this.mapping = new Map();
+ }
+ CaptureService.prototype.getMap = function (code) {
+ return this.mapping.get(code);
+ };
+ CaptureService.prototype.hasMap = function (code) {
+ return this.mapping.has(code);
+ };
+ CaptureService.prototype.setModifier = function (left, code) {
+ return left ? this.leftModifiers.set(code, true) : this.rightModifiers.set(code, true);
+ };
+ CaptureService.prototype.getModifiers = function (left) {
+ return left ? this.reMap(this.leftModifiers) : this.reMap(this.rightModifiers);
+ };
+ CaptureService.prototype.initModifiers = function () {
+ this.leftModifiers.set(16, false); // Shift
+ this.leftModifiers.set(17, false); // Ctrl
+ this.leftModifiers.set(18, false); // Alt
+ this.leftModifiers.set(91, false); // Super
+ this.rightModifiers.set(16, false); // Shift
+ this.rightModifiers.set(17, false); // Ctrl
+ this.rightModifiers.set(18, false); // Alt
+ this.rightModifiers.set(91, false); // Super
+ };
+ CaptureService.prototype.populateMapping = function () {
+ this.mapping.set(8, 42); // Backspace
+ this.mapping.set(9, 43); // Tab
+ this.mapping.set(13, 40); // Enter
+ this.mapping.set(19, 72); // Pause/break
+ this.mapping.set(20, 57); // Caps lock
+ this.mapping.set(27, 41); // Escape
+ this.mapping.set(32, 44); // (space)
+ this.mapping.set(33, 75); // Page up
+ this.mapping.set(34, 78); // Page down
+ this.mapping.set(35, 77); // End
+ this.mapping.set(36, 74); // Home
+ this.mapping.set(37, 80); // Left arrow
+ this.mapping.set(38, 82); // Up arrow
+ this.mapping.set(39, 79); // Right arrow
+ this.mapping.set(40, 81); // Down arrow
+ this.mapping.set(45, 73); // Insert
+ this.mapping.set(46, 76); // Delete
+ this.mapping.set(48, 39); // 0
+ this.mapping.set(49, 30); // 1
+ this.mapping.set(50, 31); // 2
+ this.mapping.set(51, 32); // 3
+ this.mapping.set(52, 33); // 4
+ this.mapping.set(53, 34); // 5
+ this.mapping.set(54, 35); // 6
+ this.mapping.set(55, 36); // 7
+ this.mapping.set(56, 37); // 8
+ this.mapping.set(57, 38); // 9
+ this.mapping.set(65, 4); // A
+ this.mapping.set(66, 5); // B
+ this.mapping.set(67, 6); // C
+ this.mapping.set(68, 7); // D
+ this.mapping.set(69, 8); // E
+ this.mapping.set(70, 9); // F
+ this.mapping.set(71, 10); // G
+ this.mapping.set(72, 11); // H
+ this.mapping.set(73, 12); // I
+ this.mapping.set(74, 13); // J
+ this.mapping.set(75, 14); // K
+ this.mapping.set(76, 15); // L
+ this.mapping.set(77, 16); // M
+ this.mapping.set(78, 17); // N
+ this.mapping.set(79, 18); // O
+ this.mapping.set(80, 19); // P
+ this.mapping.set(81, 20); // Q
+ this.mapping.set(82, 21); // R
+ this.mapping.set(83, 22); // S
+ this.mapping.set(84, 23); // T
+ this.mapping.set(85, 24); // U
+ this.mapping.set(86, 25); // V
+ this.mapping.set(87, 26); // W
+ this.mapping.set(88, 27); // X
+ this.mapping.set(89, 28); // Y
+ this.mapping.set(90, 29); // Z
+ this.mapping.set(93, 118); // Menu
+ this.mapping.set(96, 98); // Num pad 0
+ this.mapping.set(97, 89); // Num pad 1
+ this.mapping.set(98, 90); // Num pad 2
+ this.mapping.set(99, 91); // Num pad 3
+ this.mapping.set(100, 92); // Num pad 4
+ this.mapping.set(101, 93); // Num pad 5
+ this.mapping.set(102, 94); // Num pad 6
+ this.mapping.set(103, 95); // Num pad 7
+ this.mapping.set(104, 96); // Num pad 8
+ this.mapping.set(105, 97); // Num pad 9
+ this.mapping.set(106, 85); // Multiply
+ this.mapping.set(107, 87); // Add
+ this.mapping.set(109, 86); // Subtract
+ this.mapping.set(110, 99); // Decimal point
+ this.mapping.set(111, 84); // Divide
+ this.mapping.set(112, 58); // F1
+ this.mapping.set(113, 59); // F2
+ this.mapping.set(114, 60); // F3
+ this.mapping.set(115, 61); // F4
+ this.mapping.set(116, 62); // F5
+ this.mapping.set(117, 63); // F6
+ this.mapping.set(118, 64); // F7
+ this.mapping.set(119, 65); // F8
+ this.mapping.set(120, 66); // F9
+ this.mapping.set(121, 67); // F10
+ this.mapping.set(122, 68); // F11
+ this.mapping.set(123, 69); // F12
+ this.mapping.set(144, 83); // Num lock
+ this.mapping.set(145, 71); // Scroll lock
+ this.mapping.set(186, 51); // Semi-colon
+ this.mapping.set(187, 46); // Equal sign
+ this.mapping.set(188, 54); // Comma
+ this.mapping.set(189, 45); // Dash
+ this.mapping.set(190, 55); // Period
+ this.mapping.set(191, 56); // Forward slash
+ this.mapping.set(192, 53); // Grave accent
+ this.mapping.set(219, 47); // Open bracket
+ this.mapping.set(220, 49); // Back slash
+ this.mapping.set(221, 48); // Close bracket
+ this.mapping.set(222, 52); // Single quote
+ };
+ CaptureService.prototype.reMap = function (value) {
+ return [value.get(16), value.get(17), value.get(91), value.get(18)];
+ };
+ return CaptureService;
+}());
+CaptureService = __decorate([
+ core_1.Injectable(),
+ __metadata("design:paramtypes", [])
+], CaptureService);
+exports.CaptureService = CaptureService;
+
+
+/***/ }),
+/* 143 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var reselect_1 = __webpack_require__(730);
+var autoUpdate = __webpack_require__(144);
+exports.getUserConfiguration = function (state) { return state.userConfiguration; };
+exports.appUpdateState = function (state) { return state.autoUpdateSettings; };
+exports.getAutoUpdateSettings = reselect_1.createSelector(exports.appUpdateState, autoUpdate.getUpdateSettings);
+exports.getCheckingForUpdate = reselect_1.createSelector(exports.appUpdateState, autoUpdate.checkingForUpdate);
+
+
+/***/ }),
+/* 144 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var auto_update_settings_1 = __webpack_require__(145);
+var app_update_action_1 = __webpack_require__(731);
+exports.initialState = {
+ checkForUpdateOnStartUp: false,
+ usePreReleaseUpdate: false,
+ checkingForUpdate: false
+};
+function reducer(state, action) {
+ if (state === void 0) { state = exports.initialState; }
+ switch (action.type) {
+ case auto_update_settings_1.ActionTypes.TOGGLE_CHECK_FOR_UPDATE_ON_STARTUP: {
+ return Object.assign({}, state, { checkForUpdateOnStartUp: action.payload });
+ }
+ case auto_update_settings_1.ActionTypes.TOGGLE_PRE_RELEASE_FLAG: {
+ return Object.assign({}, state, { usePreReleaseUpdate: action.payload });
+ }
+ case auto_update_settings_1.ActionTypes.LOAD_AUTO_UPDATE_SETTINGS_SUCCESS: {
+ return Object.assign({}, action.payload);
+ }
+ case auto_update_settings_1.ActionTypes.CHECK_FOR_UPDATE_NOW: {
+ return Object.assign({}, state, { checkingForUpdate: true });
+ }
+ case app_update_action_1.ActionTypes.UPDATE_ERROR:
+ case auto_update_settings_1.ActionTypes.CHECK_FOR_UPDATE_SUCCESS:
+ case auto_update_settings_1.ActionTypes.CHECK_FOR_UPDATE_FAILED: {
+ return Object.assign({}, state, { checkingForUpdate: false });
+ }
+ default:
+ return state;
+ }
+}
+exports.reducer = reducer;
+exports.getUpdateSettings = function (state) { return ({
+ checkForUpdateOnStartUp: state.checkForUpdateOnStartUp,
+ usePreReleaseUpdate: state.usePreReleaseUpdate
+}); };
+exports.checkingForUpdate = function (state) { return state.checkingForUpdate; };
+
+
+/***/ }),
+/* 145 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = __webpack_require__(57);
+var PREFIX = '[app-update-config] ';
+// tslint:disable-next-line:variable-name
+exports.ActionTypes = {
+ TOGGLE_CHECK_FOR_UPDATE_ON_STARTUP: util_1.type(PREFIX + 'Check for update on startup'),
+ CHECK_FOR_UPDATE_NOW: util_1.type(PREFIX + 'Check for update now'),
+ CHECK_FOR_UPDATE_SUCCESS: util_1.type(PREFIX + 'Check for update success'),
+ CHECK_FOR_UPDATE_FAILED: util_1.type(PREFIX + 'Check for update faild'),
+ TOGGLE_PRE_RELEASE_FLAG: util_1.type(PREFIX + 'Toggle pre release update flag'),
+ LOAD_AUTO_UPDATE_SETTINGS: util_1.type(PREFIX + 'Load auto update settings'),
+ LOAD_AUTO_UPDATE_SETTINGS_SUCCESS: util_1.type(PREFIX + 'Load auto update settings success'),
+ SAVE_AUTO_UPDATE_SETTINGS_SUCCESS: util_1.type(PREFIX + 'Save auto update settings success')
+};
+var ToggleCheckForUpdateOnStartupAction = (function () {
+ function ToggleCheckForUpdateOnStartupAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.TOGGLE_CHECK_FOR_UPDATE_ON_STARTUP;
+ }
+ return ToggleCheckForUpdateOnStartupAction;
+}());
+exports.ToggleCheckForUpdateOnStartupAction = ToggleCheckForUpdateOnStartupAction;
+var CheckForUpdateNowAction = (function () {
+ function CheckForUpdateNowAction() {
+ this.type = exports.ActionTypes.CHECK_FOR_UPDATE_NOW;
+ }
+ return CheckForUpdateNowAction;
+}());
+exports.CheckForUpdateNowAction = CheckForUpdateNowAction;
+var CheckForUpdateSuccessAction = (function () {
+ function CheckForUpdateSuccessAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.CHECK_FOR_UPDATE_SUCCESS;
+ }
+ return CheckForUpdateSuccessAction;
+}());
+exports.CheckForUpdateSuccessAction = CheckForUpdateSuccessAction;
+var CheckForUpdateFailedAction = (function () {
+ function CheckForUpdateFailedAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.CHECK_FOR_UPDATE_FAILED;
+ }
+ return CheckForUpdateFailedAction;
+}());
+exports.CheckForUpdateFailedAction = CheckForUpdateFailedAction;
+var TogglePreReleaseFlagAction = (function () {
+ function TogglePreReleaseFlagAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.TOGGLE_PRE_RELEASE_FLAG;
+ }
+ return TogglePreReleaseFlagAction;
+}());
+exports.TogglePreReleaseFlagAction = TogglePreReleaseFlagAction;
+var LoadAutoUpdateSettingsAction = (function () {
+ function LoadAutoUpdateSettingsAction() {
+ this.type = exports.ActionTypes.LOAD_AUTO_UPDATE_SETTINGS_SUCCESS;
+ }
+ return LoadAutoUpdateSettingsAction;
+}());
+exports.LoadAutoUpdateSettingsAction = LoadAutoUpdateSettingsAction;
+var LoadAutoUpdateSettingsSuccessAction = (function () {
+ function LoadAutoUpdateSettingsSuccessAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.LOAD_AUTO_UPDATE_SETTINGS_SUCCESS;
+ }
+ return LoadAutoUpdateSettingsSuccessAction;
+}());
+exports.LoadAutoUpdateSettingsSuccessAction = LoadAutoUpdateSettingsSuccessAction;
+var SaveAutoUpdateSettingsSuccessAction = (function () {
+ function SaveAutoUpdateSettingsSuccessAction() {
+ this.type = exports.ActionTypes.SAVE_AUTO_UPDATE_SETTINGS_SUCCESS;
+ }
+ return SaveAutoUpdateSettingsSuccessAction;
+}());
+exports.SaveAutoUpdateSettingsSuccessAction = SaveAutoUpdateSettingsSuccessAction;
+
+
+/***/ }),
+/* 146 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+exports.DATA_STORAGE_REPOSITORY = new core_1.InjectionToken('dataStorage-repository');
+
+
+/***/ }),
+/* 147 */
/***/ (function(module, exports) {
// Copyright Joyent, Inc. and other Node contributors.
@@ -1567,25 +3956,92 @@ function isUndefined(arg) {
/***/ }),
-/* 176 */,
-/* 177 */,
-/* 178 */,
-/* 179 */,
-/* 180 */,
-/* 181 */,
-/* 182 */,
-/* 183 */,
-/* 184 */,
-/* 185 */,
-/* 186 */,
-/* 187 */,
-/* 188 */,
-/* 189 */,
-/* 190 */,
-/* 191 */
+/* 148 */
/***/ (function(module, exports, __webpack_require__) {
-// Copyright Joyent, Inc. and other Node contributors.
+exports = module.exports = __webpack_require__(251);
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = __webpack_require__(150);
+exports.Duplex = __webpack_require__(50);
+exports.Transform = __webpack_require__(255);
+exports.PassThrough = __webpack_require__(837);
+
+
+/***/ }),
+/* 149 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* eslint-disable node/no-deprecated-api */
+var buffer = __webpack_require__(75)
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+ for (var key in src) {
+ dst[key] = src[key]
+ }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+ module.exports = buffer
+} else {
+ // Copy properties from require('buffer')
+ copyProps(buffer, exports)
+ exports.Buffer = SafeBuffer
+}
+
+function SafeBuffer (arg, encodingOrOffset, length) {
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+ if (typeof arg === 'number') {
+ throw new TypeError('Argument must not be a number')
+ }
+ return Buffer(arg, encodingOrOffset, length)
+}
+
+SafeBuffer.alloc = function (size, fill, encoding) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ var buf = Buffer(size)
+ if (fill !== undefined) {
+ if (typeof encoding === 'string') {
+ buf.fill(fill, encoding)
+ } else {
+ buf.fill(fill)
+ }
+ } else {
+ buf.fill(0)
+ }
+ return buf
+}
+
+SafeBuffer.allocUnsafe = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return Buffer(size)
+}
+
+SafeBuffer.allocUnsafeSlow = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return buffer.SlowBuffer(size)
+}
+
+
+/***/ }),
+/* 150 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process, setImmediate, global) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
@@ -1606,834 +4062,39 @@ function isUndefined(arg) {
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-module.exports = Stream;
-
-var EE = __webpack_require__(175).EventEmitter;
-var inherits = __webpack_require__(92);
-
-inherits(Stream, EE);
-Stream.Readable = __webpack_require__(759);
-Stream.Writable = __webpack_require__(761);
-Stream.Duplex = __webpack_require__(756);
-Stream.Transform = __webpack_require__(760);
-Stream.PassThrough = __webpack_require__(758);
-
-// Backwards-compat with node 0.4.x
-Stream.Stream = Stream;
-
-
-
-// old-style streams. Note that the pipe method (the only relevant
-// part of this class) is overridden in the Readable class.
-
-function Stream() {
- EE.call(this);
-}
-
-Stream.prototype.pipe = function(dest, options) {
- var source = this;
-
- function ondata(chunk) {
- if (dest.writable) {
- if (false === dest.write(chunk) && source.pause) {
- source.pause();
- }
- }
- }
-
- source.on('data', ondata);
-
- function ondrain() {
- if (source.readable && source.resume) {
- source.resume();
- }
- }
-
- dest.on('drain', ondrain);
-
- // If the 'end' option is not supplied, dest.end() will be called when
- // source gets the 'end' or 'close' events. Only dest.end() once.
- if (!dest._isStdio && (!options || options.end !== false)) {
- source.on('end', onend);
- source.on('close', onclose);
- }
-
- var didOnEnd = false;
- function onend() {
- if (didOnEnd) return;
- didOnEnd = true;
-
- dest.end();
- }
-
-
- function onclose() {
- if (didOnEnd) return;
- didOnEnd = true;
-
- if (typeof dest.destroy === 'function') dest.destroy();
- }
-
- // don't leave dangling pipes when there are errors.
- function onerror(er) {
- cleanup();
- if (EE.listenerCount(this, 'error') === 0) {
- throw er; // Unhandled stream error in pipe.
- }
- }
-
- source.on('error', onerror);
- dest.on('error', onerror);
-
- // remove all the event listeners that were added.
- function cleanup() {
- source.removeListener('data', ondata);
- dest.removeListener('drain', ondrain);
-
- source.removeListener('end', onend);
- source.removeListener('close', onclose);
-
- source.removeListener('error', onerror);
- dest.removeListener('error', onerror);
-
- source.removeListener('end', cleanup);
- source.removeListener('close', cleanup);
-
- dest.removeListener('close', cleanup);
- }
-
- source.on('end', cleanup);
- source.on('close', cleanup);
-
- dest.on('close', cleanup);
-
- dest.emit('pipe', source);
-
- // Allow for unix-like usage: A.pipe(B).pipe(C)
- return dest;
-};
-
-
-/***/ }),
-/* 192 */,
-/* 193 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(67));
-var keymap_1 = __webpack_require__(1040);
-exports.KeymapTabComponent = keymap_1.KeymapTabComponent;
-var keypress_1 = __webpack_require__(1042);
-exports.KeypressTabComponent = keypress_1.KeypressTabComponent;
-var layer_1 = __webpack_require__(1044);
-exports.LayerTabComponent = layer_1.LayerTabComponent;
-var macro_1 = __webpack_require__(1046);
-exports.MacroTabComponent = macro_1.MacroTabComponent;
-var mouse_1 = __webpack_require__(1048);
-exports.MouseTabComponent = mouse_1.MouseTabComponent;
-var none_1 = __webpack_require__(1050);
-exports.NoneTabComponent = none_1.NoneTabComponent;
-
-
-/***/ }),
-/* 194 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var macro_action_1 = __webpack_require__(69);
-var Macro = (function () {
- function Macro(other) {
- if (!other) {
- return;
- }
- this.id = other.id;
- this.isLooped = other.isLooped;
- this.isPrivate = other.isPrivate;
- this.name = other.name;
- this.macroActions = other.macroActions.map(function (macroAction) { return macro_action_1.Helper.createMacroAction(macroAction); });
- }
- Macro.prototype.fromJsonObject = function (jsonObject) {
- this.isLooped = jsonObject.isLooped;
- this.isPrivate = jsonObject.isPrivate;
- this.name = jsonObject.name;
- this.macroActions = jsonObject.macroActions.map(function (macroAction) { return macro_action_1.Helper.createMacroAction(macroAction); });
- return this;
- };
- Macro.prototype.fromBinary = function (buffer) {
- this.isLooped = buffer.readBoolean();
- this.isPrivate = buffer.readBoolean();
- this.name = buffer.readString();
- var macroActionsLength = buffer.readCompactLength();
- this.macroActions = [];
- for (var i = 0; i < macroActionsLength; ++i) {
- this.macroActions.push(macro_action_1.Helper.createMacroAction(buffer));
- }
- return this;
- };
- Macro.prototype.toJsonObject = function () {
- return {
- isLooped: this.isLooped,
- isPrivate: this.isPrivate,
- name: this.name,
- macroActions: this.macroActions.map(function (macroAction) { return macroAction.toJsonObject(); })
- };
- };
- Macro.prototype.toBinary = function (buffer) {
- buffer.writeBoolean(this.isLooped);
- buffer.writeBoolean(this.isPrivate);
- buffer.writeString(this.name);
- buffer.writeArray(this.macroActions);
- };
- Macro.prototype.toString = function () {
- return "";
- };
- return Macro;
-}());
-__decorate([
- assert_1.assertUInt8,
- __metadata("design:type", Number)
-], Macro.prototype, "id", void 0);
-exports.Macro = Macro;
-
-
-/***/ }),
-/* 195 */,
-/* 196 */,
-/* 197 */,
-/* 198 */,
-/* 199 */,
-/* 200 */,
-/* 201 */,
-/* 202 */,
-/* 203 */,
-/* 204 */,
-/* 205 */,
-/* 206 */,
-/* 207 */,
-/* 208 */,
-/* 209 */,
-/* 210 */,
-/* 211 */,
-/* 212 */,
-/* 213 */,
-/* 214 */,
-/* 215 */,
-/* 216 */,
-/* 217 */,
-/* 218 */,
-/* 219 */,
-/* 220 */,
-/* 221 */,
-/* 222 */,
-/* 223 */,
-/* 224 */,
-/* 225 */,
-/* 226 */,
-/* 227 */,
-/* 228 */,
-/* 229 */,
-/* 230 */,
-/* 231 */,
-/* 232 */,
-/* 233 */,
-/* 234 */,
-/* 235 */,
-/* 236 */,
-/* 237 */,
-/* 238 */,
-/* 239 */,
-/* 240 */,
-/* 241 */,
-/* 242 */,
-/* 243 */,
-/* 244 */,
-/* 245 */,
-/* 246 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var pluck_1 = __webpack_require__(284);
-var map_1 = __webpack_require__(23);
-var distinctUntilChanged_1 = __webpack_require__(182);
-function select(pathOrMapFn) {
- var paths = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- paths[_i - 1] = arguments[_i];
- }
- var mapped$;
- if (typeof pathOrMapFn === 'string') {
- mapped$ = pluck_1.pluck.call.apply(pluck_1.pluck, [this, pathOrMapFn].concat(paths));
- }
- else if (typeof pathOrMapFn === 'function') {
- mapped$ = map_1.map.call(this, pathOrMapFn);
- }
- else {
- throw new TypeError(("Unexpected type " + typeof pathOrMapFn + " in select operator,")
- + " expected 'string' or 'function'");
- }
- return distinctUntilChanged_1.distinctUntilChanged.call(mapped$);
-}
-exports.select = select;
-
-
-/***/ }),
-/* 247 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__src_instrument__ = __webpack_require__(587);
-/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "StoreDevtoolsModule", function() { return __WEBPACK_IMPORTED_MODULE_0__src_instrument__["a"]; });
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__src_devtools__ = __webpack_require__(381);
-/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "StoreDevtools", function() { return __WEBPACK_IMPORTED_MODULE_1__src_devtools__["a"]; });
-
-
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-/* 248 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return ActionTypes; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return StoreDevtoolActions; });
-var ActionTypes = {
- PERFORM_ACTION: 'PERFORM_ACTION',
- RESET: 'RESET',
- ROLLBACK: 'ROLLBACK',
- COMMIT: 'COMMIT',
- SWEEP: 'SWEEP',
- TOGGLE_ACTION: 'TOGGLE_ACTION',
- SET_ACTIONS_ACTIVE: 'SET_ACTIONS_ACTIVE',
- JUMP_TO_STATE: 'JUMP_TO_STATE',
- IMPORT_STATE: 'IMPORT_STATE'
-};
-/**
-* Action creators to change the History state.
-*/
-var StoreDevtoolActions = {
- performAction: function (action) {
- if (typeof action.type === 'undefined') {
- throw new Error('Actions may not have an undefined "type" property. ' +
- 'Have you misspelled a constant?');
- }
- return { type: ActionTypes.PERFORM_ACTION, action: action, timestamp: Date.now() };
- },
- reset: function () {
- return { type: ActionTypes.RESET, timestamp: Date.now() };
- },
- rollback: function () {
- return { type: ActionTypes.ROLLBACK, timestamp: Date.now() };
- },
- commit: function () {
- return { type: ActionTypes.COMMIT, timestamp: Date.now() };
- },
- sweep: function () {
- return { type: ActionTypes.SWEEP };
- },
- toggleAction: function (id) {
- return { type: ActionTypes.TOGGLE_ACTION, id: id };
- },
- setActionsActive: function (start, end, active) {
- if (active === void 0) { active = true; }
- return { type: ActionTypes.SET_ACTIONS_ACTIVE, start: start, end: end, active: active };
- },
- jumpToState: function (index) {
- return { type: ActionTypes.JUMP_TO_STATE, index: index };
- },
- importState: function (nextLiftedState) {
- return { type: ActionTypes.IMPORT_STATE, nextLiftedState: nextLiftedState };
- }
-};
-//# sourceMappingURL=actions.js.map
-
-/***/ }),
-/* 249 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__actions__ = __webpack_require__(248);
-/* harmony export (immutable) */ __webpack_exports__["d"] = difference;
-/* harmony export (immutable) */ __webpack_exports__["c"] = unliftState;
-/* unused harmony export unliftAction */
-/* harmony export (immutable) */ __webpack_exports__["b"] = liftAction;
-/* harmony export (immutable) */ __webpack_exports__["a"] = applyOperators;
-
-function difference(first, second) {
- return first.filter(function (item) { return second.indexOf(item) < 0; });
-}
-/**
- * Provides an app's view into the state of the lifted store.
- */
-function unliftState(liftedState) {
- var computedStates = liftedState.computedStates, currentStateIndex = liftedState.currentStateIndex;
- var state = computedStates[currentStateIndex].state;
- return state;
-}
-function unliftAction(liftedState) {
- return liftedState.actionsById[liftedState.nextActionId - 1];
-}
-/**
-* Lifts an app's action into an action on the lifted store.
-*/
-function liftAction(action) {
- return __WEBPACK_IMPORTED_MODULE_0__actions__["a" /* StoreDevtoolActions */].performAction(action);
-}
-function applyOperators(input$, operators) {
- return operators.reduce(function (source$, _a) {
- var operator = _a[0], args = _a.slice(1);
- return operator.apply(source$, args);
- }, input$);
-}
-//# sourceMappingURL=utils.js.map
-
-/***/ }),
-/* 250 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DockActions; });
-
-var DockActions = (function () {
- function DockActions() {
- }
- DockActions.prototype.toggleVisibility = function () {
- return { type: DockActions.TOGGLE_VISIBILITY };
- };
- DockActions.prototype.changePosition = function () {
- return { type: DockActions.CHANGE_POSITION };
- };
- DockActions.prototype.changeSize = function (size) {
- return { type: DockActions.CHANGE_SIZE, payload: size };
- };
- DockActions.prototype.changeMonitor = function () {
- return { type: DockActions.CHANGE_MONITOR };
- };
- DockActions.TOGGLE_VISIBILITY = '@@redux-devtools-log-monitor/TOGGLE_VISIBILITY';
- DockActions.CHANGE_POSITION = '@@redux-devtools-log-monitor/CHANGE_POSITION';
- DockActions.CHANGE_SIZE = '@@redux-devtools-log-monitor/CHANGE_SIZE';
- DockActions.CHANGE_MONITOR = '@@redux-devtools-log-monitor/CHANGE_MONITOR';
- DockActions.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
- ];
- /** @nocollapse */
- DockActions.ctorParameters = [];
- return DockActions;
-}());
-//# sourceMappingURL=actions.js.map
-
-/***/ }),
-/* 251 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-
-var buffer = __webpack_require__(56);
-var Buffer = buffer.Buffer;
-var SlowBuffer = buffer.SlowBuffer;
-var MAX_LEN = buffer.kMaxLength || 2147483647;
-exports.alloc = function alloc(size, fill, encoding) {
- if (typeof Buffer.alloc === 'function') {
- return Buffer.alloc(size, fill, encoding);
- }
- if (typeof encoding === 'number') {
- throw new TypeError('encoding must not be number');
- }
- if (typeof size !== 'number') {
- throw new TypeError('size must be a number');
- }
- if (size > MAX_LEN) {
- throw new RangeError('size is too large');
- }
- var enc = encoding;
- var _fill = fill;
- if (_fill === undefined) {
- enc = undefined;
- _fill = 0;
- }
- var buf = new Buffer(size);
- if (typeof _fill === 'string') {
- var fillBuf = new Buffer(_fill, enc);
- var flen = fillBuf.length;
- var i = -1;
- while (++i < size) {
- buf[i] = fillBuf[i % flen];
- }
- } else {
- buf.fill(_fill);
- }
- return buf;
-}
-exports.allocUnsafe = function allocUnsafe(size) {
- if (typeof Buffer.allocUnsafe === 'function') {
- return Buffer.allocUnsafe(size);
- }
- if (typeof size !== 'number') {
- throw new TypeError('size must be a number');
- }
- if (size > MAX_LEN) {
- throw new RangeError('size is too large');
- }
- return new Buffer(size);
-}
-exports.from = function from(value, encodingOrOffset, length) {
- if (typeof Buffer.from === 'function' && (!global.Uint8Array || Uint8Array.from !== Buffer.from)) {
- return Buffer.from(value, encodingOrOffset, length);
- }
- if (typeof value === 'number') {
- throw new TypeError('"value" argument must not be a number');
- }
- if (typeof value === 'string') {
- return new Buffer(value, encodingOrOffset);
- }
- if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
- var offset = encodingOrOffset;
- if (arguments.length === 1) {
- return new Buffer(value);
- }
- if (typeof offset === 'undefined') {
- offset = 0;
- }
- var len = length;
- if (typeof len === 'undefined') {
- len = value.byteLength - offset;
- }
- if (offset >= value.byteLength) {
- throw new RangeError('\'offset\' is out of bounds');
- }
- if (len > value.byteLength - offset) {
- throw new RangeError('\'length\' is out of bounds');
- }
- return new Buffer(value.slice(offset, offset + len));
- }
- if (Buffer.isBuffer(value)) {
- var out = new Buffer(value.length);
- value.copy(out, 0, 0, value.length);
- return out;
- }
- if (value) {
- if (Array.isArray(value) || (typeof ArrayBuffer !== 'undefined' && value.buffer instanceof ArrayBuffer) || 'length' in value) {
- return new Buffer(value);
- }
- if (value.type === 'Buffer' && Array.isArray(value.data)) {
- return new Buffer(value.data);
- }
- }
-
- throw new TypeError('First argument must be a string, Buffer, ' + 'ArrayBuffer, Array, or array-like object.');
-}
-exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
- if (typeof Buffer.allocUnsafeSlow === 'function') {
- return Buffer.allocUnsafeSlow(size);
- }
- if (typeof size !== 'number') {
- throw new TypeError('size must be a number');
- }
- if (size >= MAX_LEN) {
- throw new RangeError('size is too large');
- }
- return new SlowBuffer(size);
-}
-
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(15)))
-
-/***/ }),
-/* 252 */,
-/* 253 */,
-/* 254 */,
-/* 255 */,
-/* 256 */,
-/* 257 */,
-/* 258 */,
-/* 259 */,
-/* 260 */,
-/* 261 */,
-/* 262 */,
-/* 263 */,
-/* 264 */,
-/* 265 */,
-/* 266 */,
-/* 267 */,
-/* 268 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(process) {
-
-if (!process.version ||
- process.version.indexOf('v0.') === 0 ||
- process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
- module.exports = nextTick;
-} else {
- module.exports = process.nextTick;
-}
-
-function nextTick(fn, arg1, arg2, arg3) {
- if (typeof fn !== 'function') {
- throw new TypeError('"callback" argument must be a function');
- }
- var len = arguments.length;
- var args, i;
- switch (len) {
- case 0:
- case 1:
- return process.nextTick(fn);
- case 2:
- return process.nextTick(function afterTickOne() {
- fn.call(null, arg1);
- });
- case 3:
- return process.nextTick(function afterTickTwo() {
- fn.call(null, arg1, arg2);
- });
- case 4:
- return process.nextTick(function afterTickThree() {
- fn.call(null, arg1, arg2, arg3);
- });
- default:
- args = new Array(len - 1);
- i = 0;
- while (i < args.length) {
- args[i++] = arguments[i];
- }
- return process.nextTick(function afterTick() {
- fn.apply(null, args);
- });
- }
-}
-
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(32)))
-
-/***/ }),
-/* 269 */
-/***/ (function(module, exports) {
-
-module.exports = ":host {\n display: block;\n width: 100%; }\n\n.action--editor {\n padding-top: 0;\n padding-bottom: 0;\n border-radius: 0;\n border: 0; }\n\n.nav {\n padding-bottom: 1rem; }\n .nav li a {\n border-top-right-radius: 0;\n border-bottom-right-radius: 0; }\n .nav li a.selected {\n font-style: italic; }\n .nav li a:hover {\n cursor: pointer; }\n .nav li.active {\n z-index: 2; }\n .nav li.active a.selected {\n font-style: normal; }\n .nav li.active a:after {\n content: '';\n display: block;\n position: absolute;\n width: 0;\n height: 0;\n top: 0;\n right: -4rem;\n border-color: transparent transparent transparent #337ab7;\n border-style: solid;\n border-width: 2rem; }\n\n.editor__tabs, .editor__tab-links {\n padding-top: 1rem; }\n\n.editor__tabs {\n border-left: 1px solid #ddd;\n margin-left: -1.6rem;\n padding-left: 3rem; }\n\n.editor__actions {\n float: right; }\n .editor__actions-container {\n background: #f5f5f5;\n border-top: 1px solid #ddd;\n border-bottom: 1px solid #ddd;\n padding: 1rem 1.5rem; }\n\n.flex-button-wrapper {\n display: flex;\n flex-direction: row-reverse; }\n\n.flex-button {\n align-self: flex-end; }\n"
-
-/***/ }),
-/* 270 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-// a transform stream is a readable/writable stream where you do
-// something with the data. Sometimes it's called a "filter",
-// but that's not a great name for it, since that implies a thing where
-// some bits pass through, and others are simply ignored. (That would
-// be a valid example of a transform, of course.)
-//
-// While the output is causally related to the input, it's not a
-// necessarily symmetric or synchronous transformation. For example,
-// a zlib stream might take multiple plain-text writes(), and then
-// emit a single compressed chunk some time in the future.
-//
-// Here's how this works:
-//
-// The Transform stream has all the aspects of the readable and writable
-// stream classes. When you write(chunk), that calls _write(chunk,cb)
-// internally, and returns false if there's a lot of pending writes
-// buffered up. When you call read(), that calls _read(n) until
-// there's enough pending readable data buffered up.
-//
-// In a transform stream, the written data is placed in a buffer. When
-// _read(n) is called, it transforms the queued up data, calling the
-// buffered _write cb's as it consumes chunks. If consuming a single
-// written chunk would result in multiple output chunks, then the first
-// outputted bit calls the readcb, and subsequent chunks just go into
-// the read buffer, and will cause it to emit 'readable' if necessary.
-//
-// This way, back-pressure is actually determined by the reading side,
-// since _read has to be called to start processing a new chunk. However,
-// a pathological inflate type of transform can cause excessive buffering
-// here. For example, imagine a stream where every byte of input is
-// interpreted as an integer from 0-255, and then results in that many
-// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
-// 1kb of data being output. In this case, you could write a very small
-// amount of input, and end up with a very large amount of output. In
-// such a pathological inflating mechanism, there'd be no way to tell
-// the system to stop doing the transform. A single 4MB write could
-// cause the system to run out of memory.
-//
-// However, even in such a pathological case, only a single written chunk
-// would be consumed, and then the rest would wait (un-transformed) until
-// the results of the previous transformed chunk were consumed.
-
-
-
-module.exports = Transform;
-
-var Duplex = __webpack_require__(78);
-
-/**/
-var util = __webpack_require__(120);
-util.inherits = __webpack_require__(92);
-/**/
-
-util.inherits(Transform, Duplex);
-
-function TransformState(stream) {
- this.afterTransform = function (er, data) {
- return afterTransform(stream, er, data);
- };
-
- this.needTransform = false;
- this.transforming = false;
- this.writecb = null;
- this.writechunk = null;
- this.writeencoding = null;
-}
-
-function afterTransform(stream, er, data) {
- var ts = stream._transformState;
- ts.transforming = false;
-
- var cb = ts.writecb;
-
- if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));
-
- ts.writechunk = null;
- ts.writecb = null;
-
- if (data !== null && data !== undefined) stream.push(data);
-
- cb(er);
-
- var rs = stream._readableState;
- rs.reading = false;
- if (rs.needReadable || rs.length < rs.highWaterMark) {
- stream._read(rs.highWaterMark);
- }
-}
-
-function Transform(options) {
- if (!(this instanceof Transform)) return new Transform(options);
-
- Duplex.call(this, options);
-
- this._transformState = new TransformState(this);
-
- var stream = this;
-
- // start out asking for a readable event once data is transformed.
- this._readableState.needReadable = true;
-
- // we have implemented the _read method, and done the other things
- // that Readable wants before the first _read call, so unset the
- // sync guard flag.
- this._readableState.sync = false;
-
- if (options) {
- if (typeof options.transform === 'function') this._transform = options.transform;
-
- if (typeof options.flush === 'function') this._flush = options.flush;
- }
-
- // When the writable side finishes, then flush out anything remaining.
- this.once('prefinish', function () {
- if (typeof this._flush === 'function') this._flush(function (er, data) {
- done(stream, er, data);
- });else done(stream);
- });
-}
-
-Transform.prototype.push = function (chunk, encoding) {
- this._transformState.needTransform = false;
- return Duplex.prototype.push.call(this, chunk, encoding);
-};
-
-// This is the part where you do stuff!
-// override this function in implementation classes.
-// 'chunk' is an input chunk.
-//
-// Call `push(newChunk)` to pass along transformed output
-// to the readable side. You may call 'push' zero or more times.
-//
-// Call `cb(err)` when you are done with this chunk. If you pass
-// an error, then that'll put the hurt on the whole operation. If you
-// never call cb(), then you'll never get another chunk.
-Transform.prototype._transform = function (chunk, encoding, cb) {
- throw new Error('_transform() is not implemented');
-};
-
-Transform.prototype._write = function (chunk, encoding, cb) {
- var ts = this._transformState;
- ts.writecb = cb;
- ts.writechunk = chunk;
- ts.writeencoding = encoding;
- if (!ts.transforming) {
- var rs = this._readableState;
- if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
- }
-};
-
-// Doesn't matter what the args are here.
-// _transform does all the work.
-// That we got here means that the readable side wants more data.
-Transform.prototype._read = function (n) {
- var ts = this._transformState;
-
- if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
- ts.transforming = true;
- this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
- } else {
- // mark that we need a transform, so that any data that comes in
- // will get processed, now that we've asked for it.
- ts.needTransform = true;
- }
-};
-
-function done(stream, er, data) {
- if (er) return stream.emit('error', er);
-
- if (data !== null && data !== undefined) stream.push(data);
-
- // if there's nothing in the write buffer, then that means
- // that nothing more will ever be provided
- var ws = stream._writableState;
- var ts = stream._transformState;
-
- if (ws.length) throw new Error('Calling transform done when ws.length != 0');
-
- if (ts.transforming) throw new Error('Calling transform done when still transforming');
-
- return stream.push(null);
-}
-
-/***/ }),
-/* 271 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(process, setImmediate) {// A bit simpler than readable streams.
+// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.
+/**/
+
+var processNextTick = __webpack_require__(101);
+/**/
+
module.exports = Writable;
-/**/
-var processNextTick = __webpack_require__(268);
-/**/
+/* */
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+ this.next = null;
+}
+
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+ var _this = this;
+
+ this.next = null;
+ this.entry = null;
+ this.finish = function () {
+ onCorkedFinish(_this, state);
+ };
+}
+/* */
/**/
var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;
@@ -2446,45 +4107,39 @@ var Duplex;
Writable.WritableState = WritableState;
/**/
-var util = __webpack_require__(120);
-util.inherits = __webpack_require__(92);
+var util = __webpack_require__(76);
+util.inherits = __webpack_require__(58);
/**/
/**/
var internalUtil = {
- deprecate: __webpack_require__(1121)
+ deprecate: __webpack_require__(836)
};
/**/
/**/
-var Stream;
-(function () {
- try {
- Stream = __webpack_require__(191);
- } catch (_) {} finally {
- if (!Stream) Stream = __webpack_require__(175).EventEmitter;
- }
-})();
+var Stream = __webpack_require__(252);
/**/
-var Buffer = __webpack_require__(56).Buffer;
/**/
-var bufferShim = __webpack_require__(251);
+var Buffer = __webpack_require__(149).Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
/**/
+var destroyImpl = __webpack_require__(253);
+
util.inherits(Writable, Stream);
function nop() {}
-function WriteReq(chunk, encoding, cb) {
- this.chunk = chunk;
- this.encoding = encoding;
- this.callback = cb;
- this.next = null;
-}
-
function WritableState(options, stream) {
- Duplex = Duplex || __webpack_require__(78);
+ Duplex = Duplex || __webpack_require__(50);
options = options || {};
@@ -2502,7 +4157,10 @@ function WritableState(options, stream) {
this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
// cast to ints.
- this.highWaterMark = ~ ~this.highWaterMark;
+ this.highWaterMark = Math.floor(this.highWaterMark);
+
+ // if _final has been called
+ this.finalCalled = false;
// drain event flag.
this.needDrain = false;
@@ -2513,6 +4171,9 @@ function WritableState(options, stream) {
// when 'finish' is emitted
this.finished = false;
+ // has it been destroyed
+ this.destroyed = false;
+
// should we decode strings into buffers before passing to _write?
// this is here so that some node-core streams can optimize string
// handling at a lower level.
@@ -2594,7 +4255,7 @@ WritableState.prototype.getBuffer = function getBuffer() {
Object.defineProperty(WritableState.prototype, 'buffer', {
get: internalUtil.deprecate(function () {
return this.getBuffer();
- }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
+ }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
});
} catch (_) {}
})();
@@ -2618,7 +4279,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot
}
function Writable(options) {
- Duplex = Duplex || __webpack_require__(78);
+ Duplex = Duplex || __webpack_require__(50);
// Writable ctor is applied to Duplexes, too.
// `realHasInstance` is necessary because using plain `instanceof`
@@ -2640,6 +4301,10 @@ function Writable(options) {
if (typeof options.write === 'function') this._write = options.write;
if (typeof options.writev === 'function') this._writev = options.writev;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+
+ if (typeof options.final === 'function') this._final = options.final;
}
Stream.call(this);
@@ -2657,20 +4322,16 @@ function writeAfterEnd(stream, cb) {
processNextTick(cb, er);
}
-// If we get something that is not a buffer, string, null, or undefined,
-// and we're not in objectMode, then that's an error.
-// Otherwise stream chunks are all considered to be of length=1, and the
-// watermarks determine how many objects to keep in the buffer, rather than
-// how many bytes or characters.
+// Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
function validChunk(stream, state, chunk, cb) {
var valid = true;
var er = false;
- // Always throw error if a null is written
- // if we are not in object mode then throw
- // if it is not a buffer, string, or undefined.
+
if (chunk === null) {
er = new TypeError('May not write null values to stream');
- } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
er = new TypeError('Invalid non-string/buffer chunk');
}
if (er) {
@@ -2684,19 +4345,24 @@ function validChunk(stream, state, chunk, cb) {
Writable.prototype.write = function (chunk, encoding, cb) {
var state = this._writableState;
var ret = false;
+ var isBuf = _isUint8Array(chunk) && !state.objectMode;
+
+ if (isBuf && !Buffer.isBuffer(chunk)) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
if (typeof encoding === 'function') {
cb = encoding;
encoding = null;
}
- if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+ if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
if (typeof cb !== 'function') cb = nop;
- if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) {
+ if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
state.pendingcb++;
- ret = writeOrBuffer(this, state, chunk, encoding, cb);
+ ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
}
return ret;
@@ -2728,7 +4394,7 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
function decodeChunk(state, chunk, encoding) {
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
- chunk = bufferShim.from(chunk, encoding);
+ chunk = Buffer.from(chunk, encoding);
}
return chunk;
}
@@ -2736,10 +4402,15 @@ function decodeChunk(state, chunk, encoding) {
// if we're already writing something, then just put this
// in the queue, and wait our turn. Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
-function writeOrBuffer(stream, state, chunk, encoding, cb) {
- chunk = decodeChunk(state, chunk, encoding);
-
- if (Buffer.isBuffer(chunk)) encoding = 'buffer';
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+ if (!isBuf) {
+ var newChunk = decodeChunk(state, chunk, encoding);
+ if (chunk !== newChunk) {
+ isBuf = true;
+ encoding = 'buffer';
+ chunk = newChunk;
+ }
+ }
var len = state.objectMode ? 1 : chunk.length;
state.length += len;
@@ -2750,7 +4421,13 @@ function writeOrBuffer(stream, state, chunk, encoding, cb) {
if (state.writing || state.corked) {
var last = state.lastBufferedRequest;
- state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
+ state.lastBufferedRequest = {
+ chunk: chunk,
+ encoding: encoding,
+ isBuf: isBuf,
+ callback: cb,
+ next: null
+ };
if (last) {
last.next = state.lastBufferedRequest;
} else {
@@ -2775,10 +4452,26 @@ function doWrite(stream, state, writev, len, chunk, encoding, cb) {
function onwriteError(stream, state, sync, er, cb) {
--state.pendingcb;
- if (sync) processNextTick(cb, er);else cb(er);
- stream._writableState.errorEmitted = true;
- stream.emit('error', er);
+ if (sync) {
+ // defer the callback if we are being called synchronously
+ // to avoid piling up things on the stack
+ processNextTick(cb, er);
+ // this can emit finish, and it will always happen
+ // after error
+ processNextTick(finishMaybe, stream, state);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ } else {
+ // the caller expect this to happen before if
+ // it is async
+ cb(er);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ // this can emit finish, but finish must
+ // always follow error
+ finishMaybe(stream, state);
+ }
}
function onwriteStateUpdate(state) {
@@ -2808,8 +4501,8 @@ function onwrite(stream, er) {
asyncWrite(afterWrite, stream, state, finished, cb);
/**/
} else {
- afterWrite(stream, state, finished, cb);
- }
+ afterWrite(stream, state, finished, cb);
+ }
}
}
@@ -2843,11 +4536,14 @@ function clearBuffer(stream, state) {
holder.entry = entry;
var count = 0;
+ var allBuffers = true;
while (entry) {
buffer[count] = entry;
+ if (!entry.isBuf) allBuffers = false;
entry = entry.next;
count += 1;
}
+ buffer.allBuffers = allBuffers;
doWrite(stream, state, true, state.length, buffer, '', holder.finish);
@@ -2921,23 +4617,37 @@ Writable.prototype.end = function (chunk, encoding, cb) {
function needFinish(state) {
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
-
-function prefinish(stream, state) {
- if (!state.prefinished) {
+function callFinal(stream, state) {
+ stream._final(function (err) {
+ state.pendingcb--;
+ if (err) {
+ stream.emit('error', err);
+ }
state.prefinished = true;
stream.emit('prefinish');
+ finishMaybe(stream, state);
+ });
+}
+function prefinish(stream, state) {
+ if (!state.prefinished && !state.finalCalled) {
+ if (typeof stream._final === 'function') {
+ state.pendingcb++;
+ state.finalCalled = true;
+ processNextTick(callFinal, stream, state);
+ } else {
+ state.prefinished = true;
+ stream.emit('prefinish');
+ }
}
}
function finishMaybe(stream, state) {
var need = needFinish(state);
if (need) {
+ prefinish(stream, state);
if (state.pendingcb === 0) {
- prefinish(stream, state);
state.finished = true;
stream.emit('finish');
- } else {
- prefinish(stream, state);
}
}
return need;
@@ -2953,487 +4663,1591 @@ function endWritable(stream, state, cb) {
stream.writable = false;
}
-// It seems a linked list but it is not
-// there will be only 2 of these for each stream
-function CorkedRequest(state) {
- var _this = this;
-
- this.next = null;
- this.entry = null;
-
- this.finish = function (err) {
- var entry = _this.entry;
- _this.entry = null;
- while (entry) {
- var cb = entry.callback;
- state.pendingcb--;
- cb(err);
- entry = entry.next;
- }
- if (state.corkedRequestsFree) {
- state.corkedRequestsFree.next = _this;
- } else {
- state.corkedRequestsFree = _this;
- }
- };
+function onCorkedFinish(corkReq, state, err) {
+ var entry = corkReq.entry;
+ corkReq.entry = null;
+ while (entry) {
+ var cb = entry.callback;
+ state.pendingcb--;
+ cb(err);
+ entry = entry.next;
+ }
+ if (state.corkedRequestsFree) {
+ state.corkedRequestsFree.next = corkReq;
+ } else {
+ state.corkedRequestsFree = corkReq;
+ }
}
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(32), __webpack_require__(192).setImmediate))
-/***/ }),
-/* 272 */,
-/* 273 */,
-/* 274 */,
-/* 275 */,
-/* 276 */,
-/* 277 */,
-/* 278 */,
-/* 279 */,
-/* 280 */,
-/* 281 */,
-/* 282 */,
-/* 283 */,
-/* 284 */,
-/* 285 */,
-/* 286 */,
-/* 287 */,
-/* 288 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(448));
-__export(__webpack_require__(1033));
-__export(__webpack_require__(1030));
-__export(__webpack_require__(1034));
-__export(__webpack_require__(289));
-__export(__webpack_require__(1031));
-__export(__webpack_require__(1019));
-__export(__webpack_require__(1023));
-
-
-/***/ }),
-/* 289 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var macro_not_found_component_1 = __webpack_require__(1036);
-exports.MacroNotFoundComponent = macro_not_found_component_1.MacroNotFoundComponent;
-var macro_not_found_guard_service_1 = __webpack_require__(1035);
-exports.MacroNotFoundGuard = macro_not_found_guard_service_1.MacroNotFoundGuard;
-
-
-/***/ }),
-/* 290 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var KeyModifiers;
-(function (KeyModifiers) {
- KeyModifiers[KeyModifiers["leftCtrl"] = 1] = "leftCtrl";
- KeyModifiers[KeyModifiers["leftShift"] = 2] = "leftShift";
- KeyModifiers[KeyModifiers["leftAlt"] = 4] = "leftAlt";
- KeyModifiers[KeyModifiers["leftGui"] = 8] = "leftGui";
- KeyModifiers[KeyModifiers["rightCtrl"] = 16] = "rightCtrl";
- KeyModifiers[KeyModifiers["rightShift"] = 32] = "rightShift";
- KeyModifiers[KeyModifiers["rightAlt"] = 64] = "rightAlt";
- KeyModifiers[KeyModifiers["rightGui"] = 128] = "rightGui";
-})(KeyModifiers = exports.KeyModifiers || (exports.KeyModifiers = {}));
-
-
-/***/ }),
-/* 291 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var Keymap_1 = __webpack_require__(80);
-var Macro_1 = __webpack_require__(194);
-var ModuleConfiguration_1 = __webpack_require__(1092);
-var UserConfiguration = (function () {
- function UserConfiguration() {
+Object.defineProperty(Writable.prototype, 'destroyed', {
+ get: function () {
+ if (this._writableState === undefined) {
+ return false;
}
- UserConfiguration.prototype.fromJsonObject = function (jsonObject) {
- var _this = this;
- this.dataModelVersion = jsonObject.dataModelVersion;
- this.moduleConfigurations = jsonObject.moduleConfigurations.map(function (moduleConfiguration) {
- return new ModuleConfiguration_1.ModuleConfiguration().fromJsonObject(moduleConfiguration);
- });
- this.macros = jsonObject.macros.map(function (macroJsonObject, index) {
- var macro = new Macro_1.Macro().fromJsonObject(macroJsonObject);
- macro.id = index;
- return macro;
- });
- this.keymaps = jsonObject.keymaps.map(function (keymap) { return new Keymap_1.Keymap().fromJsonObject(keymap, _this.macros); });
- return this;
+ return this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._writableState) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._writableState.destroyed = value;
+ }
+});
+
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+Writable.prototype._destroy = function (err, cb) {
+ this.end();
+ cb(err);
+};
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(38), __webpack_require__(96).setImmediate, __webpack_require__(13)))
+
+/***/ }),
+/* 151 */,
+/* 152 */,
+/* 153 */,
+/* 154 */,
+/* 155 */,
+/* 156 */,
+/* 157 */,
+/* 158 */,
+/* 159 */,
+/* 160 */,
+/* 161 */,
+/* 162 */,
+/* 163 */,
+/* 164 */,
+/* 165 */,
+/* 166 */,
+/* 167 */,
+/* 168 */,
+/* 169 */,
+/* 170 */,
+/* 171 */,
+/* 172 */,
+/* 173 */,
+/* 174 */,
+/* 175 */,
+/* 176 */,
+/* 177 */,
+/* 178 */,
+/* 179 */,
+/* 180 */,
+/* 181 */,
+/* 182 */,
+/* 183 */,
+/* 184 */,
+/* 185 */,
+/* 186 */,
+/* 187 */,
+/* 188 */,
+/* 189 */,
+/* 190 */,
+/* 191 */,
+/* 192 */,
+/* 193 */,
+/* 194 */,
+/* 195 */,
+/* 196 */,
+/* 197 */,
+/* 198 */,
+/* 199 */,
+/* 200 */,
+/* 201 */,
+/* 202 */,
+/* 203 */,
+/* 204 */,
+/* 205 */,
+/* 206 */,
+/* 207 */,
+/* 208 */,
+/* 209 */,
+/* 210 */,
+/* 211 */,
+/* 212 */,
+/* 213 */,
+/* 214 */,
+/* 215 */,
+/* 216 */,
+/* 217 */,
+/* 218 */,
+/* 219 */,
+/* 220 */,
+/* 221 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NotifierModule", function() { return NotifierModule; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NotifierService", function() { return NotifierService; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵf", function() { return NotifierContainerComponent; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵh", function() { return NotifierNotificationComponent; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵe", function() { return NotifierConfig; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵb", function() { return NotifierConfigToken; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵa", function() { return NotifierOptionsToken; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵc", function() { return notifierCustomConfigFactory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵd", function() { return notifierDefaultConfigFactory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵj", function() { return NotifierAnimationService; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵg", function() { return NotifierQueueService; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵi", function() { return NotifierTimerService; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_common__ = __webpack_require__(26);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_Subject__ = __webpack_require__(6);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_Subject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_Subject__);
+
+
+
+
+/**
+ * Notification
+ *
+ * This class describes the structure of a notifiction, including all information it needs to live, and everyone else needs to work with it.
+ */
+var NotifierNotification = (function () {
+ /**
+ * Constructor
+ *
+ * @param {?} options
+ */
+ function NotifierNotification(options) {
+ Object.assign(this, options);
+ // If not set manually, we have to create a unique notification ID by ourselves. The ID generation relies on the current browser
+ // datetime in ms, in praticular the moment this notification gets constructed. Concurrency, and thus two IDs being the exact same,
+ // is not possible due to the action queue concept.
+ if (options.id === undefined) {
+ this.id = "ID_" + new Date().getTime();
+ }
+ }
+ return NotifierNotification;
+}());
+
+/**
+ * Notifier queue service
+ *
+ * In general, API calls don't get processed right away. Instead, we have to queue them up in order to prevent simultanious API calls
+ * interfering with each other. This, at least in theory, is possible at any time. In particular, animations - which potentially overlap -
+ * can cause changes in JS classes as well as affect the DOM. Therefore, the queue service takes all actions, puts them in a queue, and
+ * processes them at the right time (which is when the previous action has been processed successfully).
+ *
+ * Technical sidenote:
+ * An action looks pretty similar to the ones within the Flux / Redux pattern.
+ */
+var NotifierQueueService = (function () {
+ /**
+ * Constructor
+ */
+ function NotifierQueueService() {
+ this.actionStream = new __WEBPACK_IMPORTED_MODULE_2_rxjs_Subject__["Subject"]();
+ this.actionQueue = [];
+ this.isActionInProgress = false;
+ }
+ /**
+ * Push a new action to the queue, and try to run it
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierQueueService.prototype.push = function (action) {
+ this.actionQueue.push(action);
+ this.tryToRunNextAction();
};
- UserConfiguration.prototype.fromBinary = function (buffer) {
- var _this = this;
- this.dataModelVersion = buffer.readUInt16();
- this.moduleConfigurations = buffer.readArray(function (uhkBuffer) {
- return new ModuleConfiguration_1.ModuleConfiguration().fromBinary(uhkBuffer);
- });
- this.macros = buffer.readArray(function (uhkBuffer, index) {
- var macro = new Macro_1.Macro().fromBinary(uhkBuffer);
- macro.id = index;
- return macro;
- });
- this.keymaps = buffer.readArray(function (uhkBuffer) { return new Keymap_1.Keymap().fromBinary(uhkBuffer, _this.macros); });
- return this;
+ /**
+ * Continue with the next action (called when the current action is finished)
+ * @return {?}
+ */
+ NotifierQueueService.prototype.continue = function () {
+ this.isActionInProgress = false;
+ this.tryToRunNextAction();
};
- UserConfiguration.prototype.toJsonObject = function () {
+ /**
+ * Try to run the next action in the queue; we skip if there already is some action in progress, or if there is no action left
+ * @return {?}
+ */
+ NotifierQueueService.prototype.tryToRunNextAction = function () {
+ if (this.isActionInProgress || this.actionQueue.length === 0) {
+ return; // Skip (the queue can now go drink a coffee as it has nothing to do anymore)
+ }
+ this.isActionInProgress = true;
+ this.actionStream.next(this.actionQueue.shift()); // Push next action to the stream, and remove the current action from the queue
+ };
+ return NotifierQueueService;
+}());
+NotifierQueueService.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+NotifierQueueService.ctorParameters = function () { return []; };
+
+/**
+ * Notifier configuration
+ *
+ * The notifier configuration defines what notifications look like, how they behave, and how they get animated. It is a global
+ * configuration, which means that it only can be set once (at the beginning), and cannot be changed afterwards. Aligning to the world of
+ * Angular, this configuration can be provided in the root app module - alternatively, a meaningful default configuration will be used.
+ */
+var NotifierConfig = (function () {
+ /**
+ * Constructor
+ *
+ * @param {?=} customOptions
+ */
+ function NotifierConfig(customOptions) {
+ if (customOptions === void 0) { customOptions = {}; }
+ // Set default values
+ this.animations = {
+ enabled: true,
+ hide: {
+ easing: 'ease',
+ offset: 50,
+ preset: 'fade',
+ speed: 300
+ },
+ overlap: 150,
+ shift: {
+ easing: 'ease',
+ speed: 300
+ },
+ show: {
+ easing: 'ease',
+ preset: 'slide',
+ speed: 300
+ }
+ };
+ this.behaviour = {
+ autoHide: 7000,
+ onClick: false,
+ onMouseover: 'pauseAutoHide',
+ showDismissButton: true,
+ stacking: 4
+ };
+ this.position = {
+ horizontal: {
+ distance: 12,
+ position: 'left'
+ },
+ vertical: {
+ distance: 12,
+ gap: 10,
+ position: 'bottom'
+ }
+ };
+ this.theme = 'material';
+ // The following merges the custom options into the notifier config, respecting the already set default values
+ // This linear, more explicit and code-sizy workflow is preferred here over a recursive one (because we know the object structure)
+ // Technical sidenote: Objects are merged, other types of values simply overwritten / copied
+ if (customOptions.theme !== undefined) {
+ this.theme = customOptions.theme;
+ }
+ if (customOptions.animations !== undefined) {
+ if (customOptions.animations.enabled !== undefined) {
+ this.animations.enabled = customOptions.animations.enabled;
+ }
+ if (customOptions.animations.overlap !== undefined) {
+ this.animations.overlap = customOptions.animations.overlap;
+ }
+ if (customOptions.animations.hide !== undefined) {
+ Object.assign(this.animations.hide, customOptions.animations.hide);
+ }
+ if (customOptions.animations.shift !== undefined) {
+ Object.assign(this.animations.shift, customOptions.animations.shift);
+ }
+ if (customOptions.animations.show !== undefined) {
+ Object.assign(this.animations.show, customOptions.animations.show);
+ }
+ }
+ if (customOptions.behaviour !== undefined) {
+ Object.assign(this.behaviour, customOptions.behaviour);
+ }
+ if (customOptions.position !== undefined) {
+ if (customOptions.position.horizontal !== undefined) {
+ Object.assign(this.position.horizontal, customOptions.position.horizontal);
+ }
+ if (customOptions.position.vertical !== undefined) {
+ Object.assign(this.position.vertical, customOptions.position.vertical);
+ }
+ }
+ }
+ return NotifierConfig;
+}());
+
+/**
+ * Notifier service
+ *
+ * This service provides access to the public notifier API. Once injected into a component, directive, pipe, service, or any other building
+ * block of an applications, it can be used to show new notifications, and hide existing ones. Internally, it transforms API calls into
+ * actions, which then get thrown into the action queue - eventually being processed at the right moment.
+ */
+var NotifierService = (function () {
+ /**
+ * Constructor
+ *
+ * @param {?} notifierQueueService
+ * @param {?} config
+ */
+ function NotifierService(notifierQueueService, config // The forwardRef is (sadly) required here
+ ) {
+ this.queueService = notifierQueueService;
+ this.config = config;
+ }
+ /**
+ * Get the notifier configuration
+ *
+ * @return {?}
+ */
+ NotifierService.prototype.getConfig = function () {
+ return this.config;
+ };
+ /**
+ * API: Show a new notification
+ *
+ * @param {?} notificationOptions
+ * @return {?}
+ */
+ NotifierService.prototype.show = function (notificationOptions) {
+ this.queueService.push({
+ payload: notificationOptions,
+ type: 'SHOW'
+ });
+ };
+ /**
+ * API: Hide a specific notification, given its ID
+ *
+ * @param {?} notificationId
+ * @return {?}
+ */
+ NotifierService.prototype.hide = function (notificationId) {
+ this.queueService.push({
+ payload: notificationId,
+ type: 'HIDE'
+ });
+ };
+ /**
+ * API: Hide the newest notification
+ * @return {?}
+ */
+ NotifierService.prototype.hideNewest = function () {
+ this.queueService.push({
+ type: 'HIDE_NEWEST'
+ });
+ };
+ /**
+ * API: Hide the oldest notification
+ * @return {?}
+ */
+ NotifierService.prototype.hideOldest = function () {
+ this.queueService.push({
+ type: 'HIDE_OLDEST'
+ });
+ };
+ /**
+ * API: Hide all notifications at once
+ * @return {?}
+ */
+ NotifierService.prototype.hideAll = function () {
+ this.queueService.push({
+ type: 'HIDE_ALL'
+ });
+ };
+ /**
+ * API: Shortcut for showing a new notification
+ *
+ * @param {?} type
+ * @param {?} message
+ * @param {?=} notificationId
+ * @return {?}
+ */
+ NotifierService.prototype.notify = function (type, message, notificationId) {
+ var /** @type {?} */ notificationOptions = {
+ message: message,
+ type: type
+ };
+ if (notificationId !== undefined) {
+ notificationOptions.id = notificationId;
+ }
+ this.show(notificationOptions);
+ };
+ return NotifierService;
+}());
+NotifierService.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+NotifierService.ctorParameters = function () { return [
+ { type: NotifierQueueService, },
+ { type: NotifierConfig, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Inject"], args: [__WEBPACK_IMPORTED_MODULE_1__angular_core__["forwardRef"](function () { return NotifierConfigToken; }),] },] },
+]; };
+
+/**
+ * Notifier container component
+ * ----------------------------
+ * This component acts as a wrapper for all notification components; consequently, it is responsible for creating a new notification
+ * component and removing an existing notification component. Being more precicely, it also handles side effects of those actions, such as
+ * shifting or even completely removing other notifications as well. Overall, this components handles actions coming from the queue service
+ * by subscribing to its action stream.
+ *
+ * Technical sidenote:
+ * This component has to be used somewhere in an application to work; it will not inject and create itself automatically, primarily in order
+ * to not break the Angular AoT compilation. Moreover, this component (and also the notification components) set their change detection
+ * strategy onPush, which means that we handle change detection manually in order to get the best performance. (#perfmatters)
+ */
+var NotifierContainerComponent = (function () {
+ /**
+ * Constructor
+ *
+ * @param {?} changeDetector
+ * @param {?} notifierQueueService
+ * @param {?} notifierService
+ */
+ function NotifierContainerComponent(changeDetector, notifierQueueService, notifierService) {
+ this.changeDetector = changeDetector;
+ this.queueService = notifierQueueService;
+ this.config = notifierService.getConfig();
+ this.notifications = [];
+ }
+ /**
+ * Component initialization lifecycle hook, connects this component to the action queue, and then handles incoming actions
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.ngOnInit = function () {
var _this = this;
+ this.queueServiceSubscription = this.queueService.actionStream.subscribe(function (action) {
+ _this.handleAction(action).then(function () {
+ _this.queueService.continue();
+ });
+ });
+ };
+ /**
+ * Component destroyment lifecycle hook, cleans up the observable subsciption
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.ngOnDestroy = function () {
+ if (this.queueServiceSubscription) {
+ this.queueServiceSubscription.unsubscribe();
+ }
+ };
+ /**
+ * Notification identifier, used as the ngFor trackby function
+ *
+ * @param {?} index
+ * @param {?} notification
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.identifyNotification = function (index, notification) {
+ return notification.id;
+ };
+ /**
+ * Event handler, handles clicks on notification dismiss buttons
+ *
+ * @param {?} notificationId
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.onNotificationDismiss = function (notificationId) {
+ this.queueService.push({
+ payload: notificationId,
+ type: 'HIDE'
+ });
+ };
+ /**
+ * Event handler, handles notification ready events
+ *
+ * @param {?} notificationComponent
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.onNotificationReady = function (notificationComponent) {
+ var /** @type {?} */ currentNotification = this.notifications[this.notifications.length - 1]; // Get the latest notification
+ currentNotification.component = notificationComponent; // Save the new omponent reference
+ this.continueHandleShowAction(currentNotification); // Continue with handling the show action
+ };
+ /**
+ * Handle incoming actions by mapping action types to methods, and then running them
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.handleAction = function (action) {
+ switch (action.type) {
+ case 'SHOW':
+ return this.handleShowAction(action);
+ case 'HIDE':
+ return this.handleHideAction(action);
+ case 'HIDE_OLDEST':
+ return this.handleHideOldestAction(action);
+ case 'HIDE_NEWEST':
+ return this.handleHideNewestAction(action);
+ case 'HIDE_ALL':
+ return this.handleHideAllAction(action);
+ default:
+ return new Promise(function (resolve, reject) {
+ resolve(); // Ignore unknown action types
+ });
+ }
+ };
+ /**
+ * Show a new notification
+ *
+ * We simply add the notification to the list, and then wait until its properly initialized / created / rendered.
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.handleShowAction = function (action) {
+ var _this = this;
+ return new Promise(function (resolve, reject) {
+ _this.tempPromiseResolver = resolve; // Save the promise resolve function so that it can be called later on by another method
+ _this.addNotificationToList(new NotifierNotification(action.payload));
+ });
+ };
+ /**
+ * Continue to show a new notification (after the notification components is initialized / created / rendered).
+ *
+ * If this is the first (and thus only) notification, we can simply show it. Otherwhise, if stacking is disabled (or a low value), we
+ * switch out notifications, in particular we hide the existing one, and then show our new one. Yet, if stacking is enabled, we first
+ * shift all older notifications, and then show our new notification. In addition, if there are too many notification on the screen,
+ * we hide the oldest one first. Furthermore, if configured, animation overlapping is applied.
+ *
+ * @param {?} notification
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.continueHandleShowAction = function (notification) {
+ var _this = this;
+ // First (which means only one) notification in the list?
+ var /** @type {?} */ numberOfNotifications = this.notifications.length;
+ if (numberOfNotifications === 1) {
+ notification.component.show().then(this.tempPromiseResolver); // Done
+ }
+ else {
+ var /** @type {?} */ implicitStackingLimit = 2;
+ // Stacking enabled? (stacking value below 2 means stacking is disabled)
+ if (this.config.behaviour.stacking === false || this.config.behaviour.stacking < implicitStackingLimit) {
+ this.notifications[0].component.hide().then(function () {
+ _this.removeNotificationFromList(_this.notifications[0]);
+ notification.component.show().then(_this.tempPromiseResolver); // Done
+ });
+ }
+ else {
+ var /** @type {?} */ stepPromises_1 = [];
+ // Are there now too many notifications?
+ if (numberOfNotifications > this.config.behaviour.stacking) {
+ var /** @type {?} */ oldNotifications_1 = this.notifications.slice(1, numberOfNotifications - 1);
+ // Are animations enabled?
+ if (this.config.animations.enabled) {
+ // Is animation overlap enabled?
+ if (this.config.animations.overlap !== false && this.config.animations.overlap > 0) {
+ stepPromises_1.push(this.notifications[0].component.hide());
+ setTimeout(function () {
+ stepPromises_1.push(_this.shiftNotifications(oldNotifications_1, notification.component.getHeight(), true));
+ }, this.config.animations.hide.speed - this.config.animations.overlap);
+ setTimeout(function () {
+ stepPromises_1.push(notification.component.show());
+ }, this.config.animations.hide.speed + this.config.animations.shift.speed - this.config.animations.overlap);
+ }
+ else {
+ stepPromises_1.push(new Promise(function (resolve, reject) {
+ _this.notifications[0].component.hide().then(function () {
+ _this.shiftNotifications(oldNotifications_1, notification.component.getHeight(), true).then(function () {
+ notification.component.show().then(resolve);
+ });
+ });
+ }));
+ }
+ }
+ else {
+ stepPromises_1.push(this.notifications[0].component.hide());
+ stepPromises_1.push(this.shiftNotifications(oldNotifications_1, notification.component.getHeight(), true));
+ stepPromises_1.push(notification.component.show());
+ }
+ }
+ else {
+ var /** @type {?} */ oldNotifications_2 = this.notifications.slice(0, numberOfNotifications - 1);
+ // Are animations enabled?
+ if (this.config.animations.enabled) {
+ // Is animation overlap enabled?
+ if (this.config.animations.overlap !== false && this.config.animations.overlap > 0) {
+ stepPromises_1.push(this.shiftNotifications(oldNotifications_2, notification.component.getHeight(), true));
+ setTimeout(function () {
+ stepPromises_1.push(notification.component.show());
+ }, this.config.animations.shift.speed - this.config.animations.overlap);
+ }
+ else {
+ stepPromises_1.push(new Promise(function (resolve, reject) {
+ _this.shiftNotifications(oldNotifications_2, notification.component.getHeight(), true).then(function () {
+ notification.component.show().then(resolve);
+ });
+ }));
+ }
+ }
+ else {
+ stepPromises_1.push(this.shiftNotifications(oldNotifications_2, notification.component.getHeight(), true));
+ stepPromises_1.push(notification.component.show());
+ }
+ }
+ Promise.all(stepPromises_1).then(function () {
+ if (numberOfNotifications > _this.config.behaviour.stacking) {
+ _this.removeNotificationFromList(_this.notifications[0]);
+ }
+ _this.tempPromiseResolver();
+ }); // Done
+ }
+ }
+ };
+ /**
+ * Hide an existing notification
+ *
+ * Fist, we skip everything if there are no notifications at all, or the given notification does not exist. Then, we hide the given
+ * notification. If there exist older notifications, we then shift them around to fill the gap. Once both hiding the given notification
+ * and shifting the older notificaitons is done, the given notification gets finally removed (from the DOM).
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.handleHideAction = function (action) {
+ var _this = this;
+ return new Promise(function (resolve, reject) {
+ var /** @type {?} */ stepPromises = [];
+ // Does the notification exist / are there even any notifications? (let's prevent accidential errors)
+ var /** @type {?} */ notification = _this.findNotificationById(action.payload);
+ if (notification === undefined) {
+ resolve();
+ return;
+ }
+ // Get older notifications
+ var /** @type {?} */ notificationIndex = _this.findNotificationIndexById(action.payload);
+ if (notificationIndex === undefined) {
+ resolve();
+ return;
+ }
+ var /** @type {?} */ oldNotifications = _this.notifications.slice(0, notificationIndex);
+ // Do older notifications exist, and thus do we need to shift other notifications as a consequence?
+ if (oldNotifications.length > 0) {
+ // Are animations enabled?
+ if (_this.config.animations.enabled && _this.config.animations.hide.speed > 0) {
+ // Is animation overlap enabled?
+ if (_this.config.animations.overlap !== false && _this.config.animations.overlap > 0) {
+ stepPromises.push(notification.component.hide());
+ setTimeout(function () {
+ stepPromises.push(_this.shiftNotifications(oldNotifications, notification.component.getHeight(), false));
+ }, _this.config.animations.hide.speed - _this.config.animations.overlap);
+ }
+ else {
+ notification.component.hide().then(function () {
+ stepPromises.push(_this.shiftNotifications(oldNotifications, notification.component.getHeight(), false));
+ });
+ }
+ }
+ else {
+ stepPromises.push(notification.component.hide());
+ stepPromises.push(_this.shiftNotifications(oldNotifications, notification.component.getHeight(), false));
+ }
+ }
+ else {
+ stepPromises.push(notification.component.hide());
+ }
+ // Wait until both hiding and shifting is done, then remove the notification from the list
+ Promise.all(stepPromises).then(function () {
+ _this.removeNotificationFromList(notification);
+ resolve(); // Done
+ });
+ });
+ };
+ /**
+ * Hide the oldest notification (bridge to handleHideAction)
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.handleHideOldestAction = function (action) {
+ // Are there any notifications? (prevent accidential errors)
+ if (this.notifications.length === 0) {
+ return new Promise(function (resolve, reject) {
+ resolve();
+ }); // Done
+ }
+ else {
+ action.payload = this.notifications[0].id;
+ return this.handleHideAction(action);
+ }
+ };
+ /**
+ * Hide the newest notification (bridge to handleHideAction)
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.handleHideNewestAction = function (action) {
+ // Are there any notifications? (prevent accidential errors)
+ if (this.notifications.length === 0) {
+ return new Promise(function (resolve, reject) {
+ resolve();
+ }); // Done
+ }
+ else {
+ action.payload = this.notifications[this.notifications.length - 1].id;
+ return this.handleHideAction(action);
+ }
+ };
+ /**
+ * Hide all notifications at once
+ *
+ * @param {?} action
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.handleHideAllAction = function (action) {
+ var _this = this;
+ return new Promise(function (resolve, reject) {
+ // Are there any notifications? (prevent accidential errors)
+ var /** @type {?} */ numberOfNotifications = _this.notifications.length;
+ if (numberOfNotifications === 0) {
+ resolve(); // Done
+ return;
+ }
+ // Are animations enabled?
+ if (_this.config.animations.enabled && _this.config.animations.hide.speed > 0 && _this.config.animations.hide.offset !== false &&
+ _this.config.animations.hide.offset > 0) {
+ var _loop_1 = function (i) {
+ var /** @type {?} */ animationOffset = _this.config.position.vertical.position === 'top' ? numberOfNotifications - 1 : i;
+ setTimeout(function () {
+ _this.notifications[i].component.hide().then(function () {
+ // Are we done here, was this the last notification to be hidden?
+ if ((_this.config.position.vertical.position === 'top' && i === 0) ||
+ (_this.config.position.vertical.position === 'bottom' && i === numberOfNotifications - 1)) {
+ _this.removeAllNotificationsFromList();
+ resolve(); // Done
+ }
+ });
+ }, _this.config.animations.hide.offset * animationOffset);
+ };
+ for (var /** @type {?} */ i = numberOfNotifications - 1; i >= 0; i--) {
+ _loop_1(/** @type {?} */ i);
+ }
+ }
+ else {
+ var /** @type {?} */ stepPromises = [];
+ for (var /** @type {?} */ i = numberOfNotifications - 1; i >= 0; i--) {
+ stepPromises.push(_this.notifications[i].component.hide());
+ }
+ Promise.all(stepPromises).then(function () {
+ _this.removeAllNotificationsFromList();
+ resolve(); // Done
+ });
+ }
+ });
+ };
+ /**
+ * Shift multiple notifications at once
+ *
+ * @param {?} notifications
+ * @param {?} distance
+ * @param {?} toMakePlace
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.shiftNotifications = function (notifications, distance, toMakePlace) {
+ return new Promise(function (resolve, reject) {
+ // Are there any notifications to shift?
+ if (notifications.length === 0) {
+ resolve();
+ return;
+ }
+ var /** @type {?} */ notificationPromises = [];
+ for (var /** @type {?} */ i = notifications.length - 1; i >= 0; i--) {
+ notificationPromises.push(notifications[i].component.shift(distance, toMakePlace));
+ }
+ Promise.all(notificationPromises).then(resolve); // Done
+ });
+ };
+ /**
+ * Add a new notification to the list of notifications (triggers change detection)
+ *
+ * @param {?} notification
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.addNotificationToList = function (notification) {
+ this.notifications.push(notification);
+ this.changeDetector.markForCheck(); // Run change detection because the notification list changed
+ };
+ /**
+ * Remove an existing notification from the list of notifications (triggers change detection)
+ *
+ * @param {?} notification
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.removeNotificationFromList = function (notification) {
+ this.notifications =
+ this.notifications.filter(function (item) { return item.component !== notification.component; });
+ this.changeDetector.markForCheck(); // Run change detection because the notification list changed
+ };
+ /**
+ * Remove all notifications from the list (triggers change detection)
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.removeAllNotificationsFromList = function () {
+ this.notifications = [];
+ this.changeDetector.markForCheck(); // Run change detection because the notification list changed
+ };
+ /**
+ * Helper: Find a notification in the notification list by a given notification ID
+ *
+ * @param {?} notificationId
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.findNotificationById = function (notificationId) {
+ return this.notifications.find(function (currentNotification) { return currentNotification.id === notificationId; });
+ };
+ /**
+ * Helper: Find a notification's index by a given notification ID
+ *
+ * @param {?} notificationId
+ * @return {?}
+ */
+ NotifierContainerComponent.prototype.findNotificationIndexById = function (notificationId) {
+ var /** @type {?} */ notificationIndex = this.notifications.findIndex(function (currentNotification) { return currentNotification.id === notificationId; });
+ return (notificationIndex !== -1 ? notificationIndex : undefined);
+ };
+ return NotifierContainerComponent;
+}());
+NotifierContainerComponent.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Component"], args: [{
+ changeDetection: __WEBPACK_IMPORTED_MODULE_1__angular_core__["ChangeDetectionStrategy"].OnPush,
+ host: {
+ class: 'notifier__container'
+ },
+ selector: 'notifier-container',
+ template: "
"
+ },] },
+];
+/**
+ * @nocollapse
+ */
+NotifierContainerComponent.ctorParameters = function () { return [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["ChangeDetectorRef"], },
+ { type: NotifierQueueService, },
+ { type: NotifierService, },
+]; };
+
+/**
+ * Fade animation preset
+ */
+var fade = {
+ hide: function (notification) {
return {
- dataModelVersion: this.dataModelVersion,
- moduleConfigurations: this.moduleConfigurations.map(function (moduleConfiguration) { return moduleConfiguration.toJsonObject(); }),
- keymaps: this.keymaps.map(function (keymap) { return keymap.toJsonObject(_this.macros); }),
- macros: this.macros.map(function (macro) { return macro.toJsonObject(); })
+ from: {
+ opacity: '1'
+ },
+ to: {
+ opacity: '0'
+ }
+ };
+ },
+ show: function (notification) {
+ return {
+ from: {
+ opacity: '0'
+ },
+ to: {
+ opacity: '1'
+ }
+ };
+ }
+};
+
+/**
+ * Slide animation preset
+ */
+var slide = {
+ hide: function (notification) {
+ // Prepare variables
+ var config = notification.component.getConfig();
+ var shift = notification.component.getShift();
+ var from;
+ var to;
+ // Configure variables, depending on configuration and component
+ if (config.position.horizontal.position === 'left') {
+ from = {
+ transform: "translate3d( 0, " + shift + "px, 0 )"
+ };
+ to = {
+ transform: "translate3d( calc( -100% - " + config.position.horizontal.distance + "px - 10px ), " + shift + "px, 0 )"
+ };
+ }
+ else if (config.position.horizontal.position === 'right') {
+ from = {
+ transform: "translate3d( 0, " + shift + "px, 0 )"
+ };
+ to = {
+ transform: "translate3d( calc( 100% + " + config.position.horizontal.distance + "px + 10px ), " + shift + "px, 0 )"
+ };
+ }
+ else {
+ var horizontalPosition = void 0;
+ if (config.position.vertical.position === 'top') {
+ horizontalPosition = "calc( -100% - " + config.position.horizontal.distance + "px - 10px )";
+ }
+ else {
+ horizontalPosition = "calc( 100% + " + config.position.horizontal.distance + "px + 10px )";
+ }
+ from = {
+ transform: "translate3d( -50%, " + shift + "px, 0 )"
+ };
+ to = {
+ transform: "translate3d( -50%, " + horizontalPosition + ", 0 )"
+ };
+ }
+ // Done
+ return {
+ from: from,
+ to: to
+ };
+ },
+ show: function (notification) {
+ // Prepare variables
+ var config = notification.component.getConfig();
+ var from;
+ var to;
+ // Configure variables, depending on configuration and component
+ if (config.position.horizontal.position === 'left') {
+ from = {
+ transform: "translate3d( calc( -100% - " + config.position.horizontal.distance + "px - 10px ), 0, 0 )"
+ };
+ to = {
+ transform: 'translate3d( 0, 0, 0 )'
+ };
+ }
+ else if (config.position.horizontal.position === 'right') {
+ from = {
+ transform: "translate3d( calc( 100% + " + config.position.horizontal.distance + "px + 10px ), 0, 0 )"
+ };
+ to = {
+ transform: 'translate3d( 0, 0, 0 )'
+ };
+ }
+ else {
+ var horizontalPosition = void 0;
+ if (config.position.vertical.position === 'top') {
+ horizontalPosition = "calc( -100% - " + config.position.horizontal.distance + "px - 10px )";
+ }
+ else {
+ horizontalPosition = "calc( 100% + " + config.position.horizontal.distance + "px + 10px )";
+ }
+ from = {
+ transform: "translate3d( -50%, " + horizontalPosition + ", 0 )"
+ };
+ to = {
+ transform: 'translate3d( -50%, 0, 0 )'
+ };
+ }
+ // Done
+ return {
+ from: from,
+ to: to
+ };
+ }
+};
+
+/**
+ * Notifier animation service
+ */
+var NotifierAnimationService = (function () {
+ /**
+ * Constructor
+ */
+ function NotifierAnimationService() {
+ this.animationPresets = {
+ fade: fade,
+ slide: slide
+ };
+ }
+ /**
+ * Get animation data
+ *
+ * This method generates all data the Web Animations API needs to animate our notification. The result depends on both the animation
+ * direction (either in or out) as well as the notifications (and its attributes) itself.
+ *
+ * @param {?} direction
+ * @param {?} notification
+ * @return {?}
+ */
+ NotifierAnimationService.prototype.getAnimationData = function (direction, notification) {
+ // Get all necessary animation data
+ var /** @type {?} */ keyframes;
+ var /** @type {?} */ duration;
+ var /** @type {?} */ easing;
+ if (direction === 'show') {
+ keyframes = this.animationPresets[notification.component.getConfig().animations.show.preset].show(notification);
+ duration = notification.component.getConfig().animations.show.speed;
+ easing = notification.component.getConfig().animations.show.easing;
+ }
+ else {
+ keyframes = this.animationPresets[notification.component.getConfig().animations.hide.preset].hide(notification);
+ duration = notification.component.getConfig().animations.hide.speed;
+ easing = notification.component.getConfig().animations.hide.easing;
+ }
+ // Build and return animation data
+ return {
+ keyframes: [
+ keyframes.from,
+ keyframes.to
+ ],
+ options: {
+ duration: duration,
+ easing: easing,
+ fill: 'forwards' // Keep the newly painted state after the animation finished
+ }
};
};
- UserConfiguration.prototype.toBinary = function (buffer) {
+ return NotifierAnimationService;
+}());
+NotifierAnimationService.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+NotifierAnimationService.ctorParameters = function () { return []; };
+
+/**
+ * Notifier timer service
+ *
+ * This service acts as a timer, needed due to the still rather limited setTimeout JavaScript API. The timer service can start and stop a
+ * timer. Furthermore, it can also pause the timer at any time, and resume later on. The timer API workd promise-based.
+ */
+var NotifierTimerService = (function () {
+ /**
+ * Constructor
+ */
+ function NotifierTimerService() {
+ this.now = 0;
+ this.remaining = 0;
+ }
+ /**
+ * Start (or resume) the timer
+ *
+ * @param {?} duration
+ * @return {?}
+ */
+ NotifierTimerService.prototype.start = function (duration) {
var _this = this;
- buffer.writeUInt16(this.dataModelVersion);
- buffer.writeArray(this.moduleConfigurations);
- buffer.writeArray(this.macros);
- buffer.writeArray(this.keymaps, function (uhkBuffer, keymap) {
- keymap.toBinary(uhkBuffer, _this.macros);
+ return new Promise(function (resolve, reject) {
+ // For the first run ...
+ _this.remaining = duration;
+ // Setup, then start the timer
+ _this.finishPromiseResolver = resolve;
+ _this.continue();
});
};
- UserConfiguration.prototype.toString = function () {
- return "";
+ /**
+ * Pause the timer
+ * @return {?}
+ */
+ NotifierTimerService.prototype.pause = function () {
+ clearTimeout(this.timerId);
+ this.remaining -= new Date().getTime() - this.now;
};
- UserConfiguration.prototype.getKeymap = function (keymapAbbreviation) {
- return this.keymaps.find(function (keymap) { return keymapAbbreviation === keymap.abbreviation; });
+ /**
+ * Continue the timer
+ * @return {?}
+ */
+ NotifierTimerService.prototype.continue = function () {
+ var _this = this;
+ this.now = new Date().getTime();
+ this.timerId = setTimeout(function () {
+ _this.finish();
+ }, this.remaining);
};
- UserConfiguration.prototype.getMacro = function (macroId) {
- return this.macros.find(function (macro) { return macroId === macro.id; });
+ /**
+ * Stop the timer
+ * @return {?}
+ */
+ NotifierTimerService.prototype.stop = function () {
+ clearTimeout(this.timerId);
+ this.remaining = 0;
};
- return UserConfiguration;
+ /**
+ * Finish up the timeout by resolving the timer promise
+ * @return {?}
+ */
+ NotifierTimerService.prototype.finish = function () {
+ this.finishPromiseResolver();
+ };
+ return NotifierTimerService;
}());
-__decorate([
- assert_1.assertUInt16,
- __metadata("design:type", Number)
-], UserConfiguration.prototype, "dataModelVersion", void 0);
-exports.UserConfiguration = UserConfiguration;
+NotifierTimerService.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+NotifierTimerService.ctorParameters = function () { return []; };
-
-/***/ }),
-/* 292 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var CaptureService = (function () {
- function CaptureService() {
- this.leftModifiers = new Map();
- this.rightModifiers = new Map();
- this.mapping = new Map();
+/**
+ * Notifier notification component
+ * -------------------------------
+ * This component is responsible for actually displaying the notification on screen. In addition, it's able to show and hide this
+ * notification, in particular to animate this notification in and out, as well as shift (move) this notification vertically around.
+ * Furthermore, the notification component handles all interactions the user has with this notification / component, such as clicks and
+ * mouse movements.
+ */
+var NotifierNotificationComponent = (function () {
+ /**
+ * Constructor
+ *
+ * @param {?} elementRef
+ * @param {?} renderer
+ * @param {?} notifierService
+ * @param {?} notifierTimerService
+ * @param {?} notifierAnimationService
+ */
+ function NotifierNotificationComponent(elementRef, renderer, notifierService, notifierTimerService, notifierAnimationService) {
+ this.config = notifierService.getConfig();
+ this.ready = new __WEBPACK_IMPORTED_MODULE_1__angular_core__["EventEmitter"]();
+ this.dismiss = new __WEBPACK_IMPORTED_MODULE_1__angular_core__["EventEmitter"]();
+ this.timerService = notifierTimerService;
+ this.animationService = notifierAnimationService;
+ this.renderer = renderer;
+ this.element = elementRef.nativeElement;
+ this.elementShift = 0;
}
- CaptureService.prototype.getMap = function (code) {
- return this.mapping.get(code);
+ /**
+ * Component after view init lifecycle hook, setts up the component and then emits the ready event
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.ngAfterViewInit = function () {
+ this.setup();
+ this.elementHeight = this.element.offsetHeight;
+ this.elementWidth = this.element.offsetWidth;
+ this.ready.emit(this);
};
- CaptureService.prototype.hasMap = function (code) {
- return this.mapping.has(code);
+ /**
+ * Get the notifier config
+ *
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.getConfig = function () {
+ return this.config;
};
- CaptureService.prototype.setModifier = function (left, code) {
- return left ? this.leftModifiers.set(code, true) : this.rightModifiers.set(code, true);
+ /**
+ * Get notification element height (in px)
+ *
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.getHeight = function () {
+ return this.elementHeight;
};
- CaptureService.prototype.getModifiers = function (left) {
- return left ? this.reMap(this.leftModifiers) : this.reMap(this.rightModifiers);
+ /**
+ * Get notification element width (in px)
+ *
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.getWidth = function () {
+ return this.elementWidth;
};
- CaptureService.prototype.initModifiers = function () {
- this.leftModifiers.set(16, false); // Shift
- this.leftModifiers.set(17, false); // Ctrl
- this.leftModifiers.set(18, false); // Alt
- this.leftModifiers.set(91, false); // Super
- this.rightModifiers.set(16, false); // Shift
- this.rightModifiers.set(17, false); // Ctrl
- this.rightModifiers.set(18, false); // Alt
- this.rightModifiers.set(91, false); // Super
+ /**
+ * Get notification shift offset (in px)
+ *
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.getShift = function () {
+ return this.elementShift;
};
- CaptureService.prototype.populateMapping = function () {
- this.mapping.set(8, 42); // Backspace
- this.mapping.set(9, 43); // Tab
- this.mapping.set(13, 40); // Enter
- this.mapping.set(19, 72); // Pause/break
- this.mapping.set(20, 57); // Caps lock
- this.mapping.set(27, 41); // Escape
- this.mapping.set(32, 44); // (space)
- this.mapping.set(33, 75); // Page up
- this.mapping.set(34, 78); // Page down
- this.mapping.set(35, 77); // End
- this.mapping.set(36, 74); // Home
- this.mapping.set(37, 80); // Left arrow
- this.mapping.set(38, 82); // Up arrow
- this.mapping.set(39, 79); // Right arrow
- this.mapping.set(40, 81); // Down arrow
- this.mapping.set(45, 73); // Insert
- this.mapping.set(46, 76); // Delete
- this.mapping.set(48, 39); // 0
- this.mapping.set(49, 30); // 1
- this.mapping.set(50, 31); // 2
- this.mapping.set(51, 32); // 3
- this.mapping.set(52, 33); // 4
- this.mapping.set(53, 34); // 5
- this.mapping.set(54, 35); // 6
- this.mapping.set(55, 36); // 7
- this.mapping.set(56, 37); // 8
- this.mapping.set(57, 38); // 9
- this.mapping.set(65, 4); // A
- this.mapping.set(66, 5); // B
- this.mapping.set(67, 6); // C
- this.mapping.set(68, 7); // D
- this.mapping.set(69, 8); // E
- this.mapping.set(70, 9); // F
- this.mapping.set(71, 10); // G
- this.mapping.set(72, 11); // H
- this.mapping.set(73, 12); // I
- this.mapping.set(74, 13); // J
- this.mapping.set(75, 14); // K
- this.mapping.set(76, 15); // L
- this.mapping.set(77, 16); // M
- this.mapping.set(78, 17); // N
- this.mapping.set(79, 18); // O
- this.mapping.set(80, 19); // P
- this.mapping.set(81, 20); // Q
- this.mapping.set(82, 21); // R
- this.mapping.set(83, 22); // S
- this.mapping.set(84, 23); // T
- this.mapping.set(85, 24); // U
- this.mapping.set(86, 25); // V
- this.mapping.set(87, 26); // W
- this.mapping.set(88, 27); // X
- this.mapping.set(89, 28); // Y
- this.mapping.set(90, 29); // Z
- this.mapping.set(93, 118); // Menu
- this.mapping.set(96, 98); // Num pad 0
- this.mapping.set(97, 89); // Num pad 1
- this.mapping.set(98, 90); // Num pad 2
- this.mapping.set(99, 91); // Num pad 3
- this.mapping.set(100, 92); // Num pad 4
- this.mapping.set(101, 93); // Num pad 5
- this.mapping.set(102, 94); // Num pad 6
- this.mapping.set(103, 95); // Num pad 7
- this.mapping.set(104, 96); // Num pad 8
- this.mapping.set(105, 97); // Num pad 9
- this.mapping.set(106, 85); // Multiply
- this.mapping.set(107, 87); // Add
- this.mapping.set(109, 86); // Subtract
- this.mapping.set(110, 99); // Decimal point
- this.mapping.set(111, 84); // Divide
- this.mapping.set(112, 58); // F1
- this.mapping.set(113, 59); // F2
- this.mapping.set(114, 60); // F3
- this.mapping.set(115, 61); // F4
- this.mapping.set(116, 62); // F5
- this.mapping.set(117, 63); // F6
- this.mapping.set(118, 64); // F7
- this.mapping.set(119, 65); // F8
- this.mapping.set(120, 66); // F9
- this.mapping.set(121, 67); // F10
- this.mapping.set(122, 68); // F11
- this.mapping.set(123, 69); // F12
- this.mapping.set(144, 83); // Num lock
- this.mapping.set(145, 71); // Scroll lock
- this.mapping.set(186, 51); // Semi-colon
- this.mapping.set(187, 46); // Equal sign
- this.mapping.set(188, 54); // Comma
- this.mapping.set(189, 45); // Dash
- this.mapping.set(190, 55); // Period
- this.mapping.set(191, 56); // Forward slash
- this.mapping.set(192, 53); // Grave accent
- this.mapping.set(219, 47); // Open bracket
- this.mapping.set(220, 49); // Back slash
- this.mapping.set(221, 48); // Close bracket
- this.mapping.set(222, 52); // Single quote
+ /**
+ * Show (animate in) this notification
+ *
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.show = function () {
+ var _this = this;
+ return new Promise(function (resolve, reject) {
+ // Are animations enabled?
+ if (_this.config.animations.enabled && _this.config.animations.show.speed > 0) {
+ // Get animation data
+ var /** @type {?} */ animationData = _this.animationService.getAnimationData('show', _this.notification);
+ // Set initial styles (styles before animation), prevents quick flicker when animation starts
+ var /** @type {?} */ animatedProperties = Object.keys(animationData.keyframes[0]);
+ for (var /** @type {?} */ i = animatedProperties.length - 1; i >= 0; i--) {
+ _this.renderer.setStyle(_this.element, animatedProperties[i], animationData.keyframes[0][animatedProperties[i]]);
+ }
+ // Animate notification in
+ _this.renderer.setStyle(_this.element, 'visibility', 'visible');
+ var /** @type {?} */ animation = _this.element.animate(animationData.keyframes, animationData.options);
+ animation.onfinish = function () {
+ _this.startAutoHideTimer();
+ resolve(); // Done
+ };
+ }
+ else {
+ // Show notification
+ _this.renderer.setStyle(_this.element, 'visibility', 'visible');
+ _this.startAutoHideTimer();
+ resolve(); // Done
+ }
+ });
};
- CaptureService.prototype.reMap = function (value) {
- return [value.get(16), value.get(17), value.get(91), value.get(18)];
+ /**
+ * Hide (animate out) this notification
+ *
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.hide = function () {
+ var _this = this;
+ return new Promise(function (resolve, reject) {
+ _this.stopAutoHideTimer();
+ // Are animations enabled?
+ if (_this.config.animations.enabled && _this.config.animations.hide.speed > 0) {
+ var /** @type {?} */ animationData = _this.animationService.getAnimationData('hide', _this.notification);
+ var /** @type {?} */ animation = _this.element.animate(animationData.keyframes, animationData.options);
+ animation.onfinish = function () {
+ resolve(); // Done
+ };
+ }
+ else {
+ resolve(); // Done
+ }
+ });
};
- return CaptureService;
+ /**
+ * Shift (move) this notification
+ *
+ * @param {?} distance
+ * @param {?} shiftToMakePlace
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.shift = function (distance, shiftToMakePlace) {
+ var _this = this;
+ return new Promise(function (resolve, reject) {
+ // Calculate new position (position after the shift)
+ var /** @type {?} */ newElementShift;
+ if ((_this.config.position.vertical.position === 'top' && shiftToMakePlace)
+ || (_this.config.position.vertical.position === 'bottom' && !shiftToMakePlace)) {
+ newElementShift = _this.elementShift + distance + _this.config.position.vertical.gap;
+ }
+ else {
+ newElementShift = _this.elementShift - distance - _this.config.position.vertical.gap;
+ }
+ var /** @type {?} */ horizontalPosition = _this.config.position.horizontal.position === 'middle' ? '-50%' : '0';
+ // Are animations enabled?
+ if (_this.config.animations.enabled && _this.config.animations.shift.speed > 0) {
+ var /** @type {?} */ animationData = {
+ keyframes: [
+ {
+ transform: "translate3d( " + horizontalPosition + ", " + _this.elementShift + "px, 0 )"
+ },
+ {
+ transform: "translate3d( " + horizontalPosition + ", " + newElementShift + "px, 0 )"
+ }
+ ],
+ options: {
+ duration: _this.config.animations.shift.speed,
+ easing: _this.config.animations.shift.easing,
+ fill: 'forwards'
+ }
+ };
+ _this.elementShift = newElementShift;
+ var /** @type {?} */ animation = _this.element.animate(animationData.keyframes, animationData.options);
+ animation.onfinish = function () {
+ resolve(); // Done
+ };
+ }
+ else {
+ _this.renderer.setStyle(_this.element, 'transform', "translate3d( " + horizontalPosition + ", " + newElementShift + "px, 0 )");
+ _this.elementShift = newElementShift;
+ resolve(); // Done
+ }
+ });
+ };
+ /**
+ * Handle click on dismiss button
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.onClickDismiss = function () {
+ this.dismiss.emit(this.notification.id);
+ };
+ /**
+ * Handle mouseover over notification area
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.onNotificationMouseover = function () {
+ if (this.config.behaviour.onMouseover === 'pauseAutoHide') {
+ this.pauseAutoHideTimer();
+ }
+ else if (this.config.behaviour.onMouseover === 'resetAutoHide') {
+ this.stopAutoHideTimer();
+ }
+ };
+ /**
+ * Handle mouseout from notification area
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.onNotificationMouseout = function () {
+ if (this.config.behaviour.onMouseover === 'pauseAutoHide') {
+ this.continueAutoHideTimer();
+ }
+ else if (this.config.behaviour.onMouseover === 'resetAutoHide') {
+ this.startAutoHideTimer();
+ }
+ };
+ /**
+ * Handle click on notification area
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.onNotificationClick = function () {
+ if (this.config.behaviour.onClick === 'hide') {
+ this.onClickDismiss();
+ }
+ };
+ /**
+ * Start the auto hide timer (if enabled)
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.startAutoHideTimer = function () {
+ var _this = this;
+ if (this.config.behaviour.autoHide !== false && this.config.behaviour.autoHide > 0) {
+ this.timerService.start(this.config.behaviour.autoHide).then(function () {
+ _this.onClickDismiss();
+ });
+ }
+ };
+ /**
+ * Pause the auto hide timer (if enabled)
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.pauseAutoHideTimer = function () {
+ if (this.config.behaviour.autoHide !== false && this.config.behaviour.autoHide > 0) {
+ this.timerService.pause();
+ }
+ };
+ /**
+ * Continue the auto hide timer (if enabled)
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.continueAutoHideTimer = function () {
+ if (this.config.behaviour.autoHide !== false && this.config.behaviour.autoHide > 0) {
+ this.timerService.continue();
+ }
+ };
+ /**
+ * Stop the auto hide timer (if enabled)
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.stopAutoHideTimer = function () {
+ if (this.config.behaviour.autoHide !== false && this.config.behaviour.autoHide > 0) {
+ this.timerService.stop();
+ }
+ };
+ /**
+ * Initial notification setup
+ * @return {?}
+ */
+ NotifierNotificationComponent.prototype.setup = function () {
+ // Set start position (initially the exact same for every new notification)
+ if (this.config.position.horizontal.position === 'left') {
+ this.renderer.setStyle(this.element, 'left', this.config.position.horizontal.distance + "px");
+ }
+ else if (this.config.position.horizontal.position === 'right') {
+ this.renderer.setStyle(this.element, 'right', this.config.position.horizontal.distance + "px");
+ }
+ else {
+ this.renderer.setStyle(this.element, 'left', '50%');
+ // Let's get the GPU handle some work as well (#perfmatters)
+ this.renderer.setStyle(this.element, 'transform', 'translate3d( -50%, 0, 0 )');
+ }
+ if (this.config.position.vertical.position === 'top') {
+ this.renderer.setStyle(this.element, 'top', this.config.position.vertical.distance + "px");
+ }
+ else {
+ this.renderer.setStyle(this.element, 'bottom', this.config.position.vertical.distance + "px");
+ }
+ // Add classes (responsible for visual design)
+ this.renderer.addClass(this.element, "notifier__notification--" + this.notification.type);
+ this.renderer.addClass(this.element, "notifier__notification--" + this.config.theme);
+ };
+ return NotifierNotificationComponent;
}());
-CaptureService = __decorate([
- core_1.Injectable(),
- __metadata("design:paramtypes", [])
-], CaptureService);
-exports.CaptureService = CaptureService;
-
-
-/***/ }),
-/* 293 */,
-/* 294 */,
-/* 295 */,
-/* 296 */,
-/* 297 */,
-/* 298 */,
-/* 299 */,
-/* 300 */,
-/* 301 */,
-/* 302 */,
-/* 303 */,
-/* 304 */,
-/* 305 */,
-/* 306 */,
-/* 307 */,
-/* 308 */,
-/* 309 */,
-/* 310 */,
-/* 311 */,
-/* 312 */,
-/* 313 */,
-/* 314 */,
-/* 315 */,
-/* 316 */,
-/* 317 */,
-/* 318 */,
-/* 319 */,
-/* 320 */,
-/* 321 */,
-/* 322 */,
-/* 323 */,
-/* 324 */,
-/* 325 */,
-/* 326 */,
-/* 327 */,
-/* 328 */,
-/* 329 */,
-/* 330 */,
-/* 331 */,
-/* 332 */,
-/* 333 */,
-/* 334 */,
-/* 335 */,
-/* 336 */,
-/* 337 */,
-/* 338 */,
-/* 339 */,
-/* 340 */,
-/* 341 */,
-/* 342 */,
-/* 343 */,
-/* 344 */,
-/* 345 */,
-/* 346 */,
-/* 347 */,
-/* 348 */,
-/* 349 */,
-/* 350 */,
-/* 351 */,
-/* 352 */,
-/* 353 */,
-/* 354 */,
-/* 355 */,
-/* 356 */,
-/* 357 */,
-/* 358 */,
-/* 359 */,
-/* 360 */,
-/* 361 */,
-/* 362 */,
-/* 363 */,
-/* 364 */,
-/* 365 */,
-/* 366 */,
-/* 367 */,
-/* 368 */,
-/* 369 */,
-/* 370 */,
-/* 371 */,
-/* 372 */,
-/* 373 */,
-/* 374 */,
-/* 375 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var Observable_1 = __webpack_require__(1);
-var select_1 = __webpack_require__(246);
-Observable_1.Observable.prototype.select = select_1.select;
-
-
-/***/ }),
-/* 376 */,
-/* 377 */,
-/* 378 */,
-/* 379 */,
-/* 380 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return STORE_DEVTOOLS_CONFIG; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return INITIAL_OPTIONS; });
-
-var STORE_DEVTOOLS_CONFIG = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["OpaqueToken"]('@ngrx/devtools Options');
-var INITIAL_OPTIONS = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["OpaqueToken"]('@ngrx/devtools Initial Config');
-//# sourceMappingURL=config.js.map
-
-/***/ }),
-/* 381 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_store__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject__ = __webpack_require__(177);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__ = __webpack_require__(23);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge__ = __webpack_require__(283);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn__ = __webpack_require__(124);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan__ = __webpack_require__(285);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip__ = __webpack_require__(425);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom__ = __webpack_require__(286);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue__ = __webpack_require__(184);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__extension__ = __webpack_require__(382);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__utils__ = __webpack_require__(249);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__reducer__ = __webpack_require__(588);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__actions__ = __webpack_require__(248);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__config__ = __webpack_require__(380);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return DevtoolsDispatcher; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return StoreDevtools; });
-var __extends = (this && this.__extends) || function (d, b) {
- for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+NotifierNotificationComponent.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Component"], args: [{
+ changeDetection: __WEBPACK_IMPORTED_MODULE_1__angular_core__["ChangeDetectionStrategy"].OnPush,
+ host: {
+ '(click)': 'onNotificationClick()',
+ '(mouseout)': 'onNotificationMouseout()',
+ '(mouseover)': 'onNotificationMouseover()',
+ class: 'notifier__notification'
+ },
+ providers: [
+ // We provide the timer to the component's local injector, so that every notification components gets its own
+ // instance of the timer service, thus running their timers independently from each other
+ NotifierTimerService
+ ],
+ selector: 'notifier-notification',
+ template: "
{{ notification.message }}
"
+ },] },
+];
+/**
+ * @nocollapse
+ */
+NotifierNotificationComponent.ctorParameters = function () { return [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["ElementRef"], },
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Renderer2"], },
+ { type: NotifierService, },
+ { type: NotifierTimerService, },
+ { type: NotifierAnimationService, },
+]; };
+NotifierNotificationComponent.propDecorators = {
+ 'notification': [{ type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Input"] },],
+ 'ready': [{ type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Output"] },],
+ 'dismiss': [{ type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Output"] },],
};
+/**
+ * Injection Token for notifier options
+ */
+var NotifierOptionsToken = new __WEBPACK_IMPORTED_MODULE_1__angular_core__["InjectionToken"]('[angular-notifier] Notifier Options');
+/**
+ * Injection Token for notifier configuration
+ */
+var NotifierConfigToken = new __WEBPACK_IMPORTED_MODULE_1__angular_core__["InjectionToken"]('[anuglar-notifier] Notifier Config');
+/**
+ * Factory for a notifier configuration with custom options
+ *
+ * Sidenote:
+ * Required as Angular AoT compilation cannot handle dynamic functions; see .
+ *
+ * @param {?} options
+ * @return {?}
+ */
+function notifierCustomConfigFactory(options) {
+ return new NotifierConfig(options);
+}
+/**
+ * Factory for a notifier configuration with default options
+ *
+ * Sidenote:
+ * Required as Angular AoT compilation cannot handle dynamic functions; see .
+ *
+ * @return {?}
+ */
+function notifierDefaultConfigFactory() {
+ return new NotifierConfig({});
+}
+/**
+ * Notifier module
+ */
+var NotifierModule = (function () {
+ function NotifierModule() {
+ }
+ /**
+ * Setup the notifier module with custom providers, in this case with a custom configuration based on the givne options
+ *
+ * @param {?=} options
+ * @return {?}
+ */
+ NotifierModule.withConfig = function (options) {
+ if (options === void 0) { options = {}; }
+ return {
+ ngModule: NotifierModule,
+ providers: [
+ // Provide the options itself upfront (as we need to inject them as dependencies -- see below)
+ {
+ provide: NotifierOptionsToken,
+ useValue: options
+ },
+ // Provide a custom notifier configuration, based on the given notifier options
+ {
+ deps: [
+ NotifierOptionsToken
+ ],
+ provide: NotifierConfigToken,
+ useFactory: notifierCustomConfigFactory
+ }
+ ]
+ };
+ };
+ return NotifierModule;
+}());
+NotifierModule.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["NgModule"], args: [{
+ declarations: [
+ NotifierContainerComponent,
+ NotifierNotificationComponent
+ ],
+ exports: [
+ NotifierContainerComponent
+ ],
+ imports: [
+ __WEBPACK_IMPORTED_MODULE_0__angular_common__["CommonModule"]
+ ],
+ providers: [
+ NotifierAnimationService,
+ NotifierService,
+ NotifierQueueService,
+ // Provide the default notifier configuration if just the module is imported
+ {
+ provide: NotifierConfigToken,
+ useFactory: notifierDefaultConfigFactory
+ }
+ ]
+ },] },
+];
+/**
+ * @nocollapse
+ */
+NotifierModule.ctorParameters = function () { return []; };
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+
+
+//# sourceMappingURL=angular-notifier.es5.js.map
+
+
+/***/ }),
+/* 222 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DevtoolsDispatcher; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return StoreDevtools; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_store__ = __webpack_require__(5);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject__ = __webpack_require__(71);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__ = __webpack_require__(16);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge__ = __webpack_require__(116);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn__ = __webpack_require__(66);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan__ = __webpack_require__(126);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip__ = __webpack_require__(193);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom__ = __webpack_require__(97);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue__ = __webpack_require__(93);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__extension__ = __webpack_require__(223);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__utils__ = __webpack_require__(131);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__reducer__ = __webpack_require__(596);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__actions__ = __webpack_require__(132);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__config__ = __webpack_require__(224);
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+
@@ -3451,31 +6265,32 @@ var __extends = (this && this.__extends) || function (d, b) {
var DevtoolsDispatcher = (function (_super) {
__extends(DevtoolsDispatcher, _super);
function DevtoolsDispatcher() {
- _super.apply(this, arguments);
+ return _super !== null && _super.apply(this, arguments) || this;
}
- DevtoolsDispatcher.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
- ];
- /** @nocollapse */
- DevtoolsDispatcher.ctorParameters = [];
return DevtoolsDispatcher;
}(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Dispatcher"]));
+
+DevtoolsDispatcher.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
+];
+/** @nocollapse */
+DevtoolsDispatcher.ctorParameters = function () { return []; };
var StoreDevtools = (function () {
function StoreDevtools(dispatcher, actions$, reducers$, extension, initialState, config) {
- var liftedInitialState = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_12__reducer__["a" /* liftInitialState */])(initialState, config.monitor);
- var liftReducer = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_12__reducer__["b" /* liftReducerWith */])(initialState, liftedInitialState, config.monitor, {
+ var liftedInitialState = __WEBPACK_IMPORTED_MODULE_12__reducer__["a" /* liftInitialState */](initialState, config.monitor);
+ var liftReducer = __WEBPACK_IMPORTED_MODULE_12__reducer__["b" /* liftReducerWith */](initialState, liftedInitialState, config.monitor, {
maxAge: config.maxAge
});
- var liftedAction$ = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_11__utils__["a" /* applyOperators */])(actions$, [
+ var liftedAction$ = __WEBPACK_IMPORTED_MODULE_11__utils__["a" /* applyOperators */](actions$, [
[__WEBPACK_IMPORTED_MODULE_7_rxjs_operator_skip__["skip"], 1],
[__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge__["merge"], extension.actions$],
- [__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__["map"], __WEBPACK_IMPORTED_MODULE_11__utils__["b" /* liftAction */]],
+ [__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__["map"], __WEBPACK_IMPORTED_MODULE_11__utils__["c" /* liftAction */]],
[__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_merge__["merge"], dispatcher, extension.liftedActions$],
[__WEBPACK_IMPORTED_MODULE_5_rxjs_operator_observeOn__["observeOn"], __WEBPACK_IMPORTED_MODULE_9_rxjs_scheduler_queue__["queue"]]
]);
var liftedReducer$ = __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__["map"].call(reducers$, liftReducer);
var liftedStateSubject = new __WEBPACK_IMPORTED_MODULE_2_rxjs_ReplaySubject__["ReplaySubject"](1);
- var liftedStateSubscription = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_11__utils__["a" /* applyOperators */])(liftedAction$, [
+ var liftedStateSubscription = __WEBPACK_IMPORTED_MODULE_11__utils__["a" /* applyOperators */](liftedAction$, [
[__WEBPACK_IMPORTED_MODULE_8_rxjs_operator_withLatestFrom__["withLatestFrom"], liftedReducer$],
[__WEBPACK_IMPORTED_MODULE_6_rxjs_operator_scan__["scan"], function (liftedState, _a) {
var action = _a[0], reducer = _a[1];
@@ -3485,7 +6300,7 @@ var StoreDevtools = (function () {
}, liftedInitialState]
]).subscribe(liftedStateSubject);
var liftedState$ = liftedStateSubject.asObservable();
- var state$ = __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__["map"].call(liftedState$, __WEBPACK_IMPORTED_MODULE_11__utils__["c" /* unliftState */]);
+ var state$ = __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_map__["map"].call(liftedState$, __WEBPACK_IMPORTED_MODULE_11__utils__["d" /* unliftState */]);
this.stateSubscription = liftedStateSubscription;
this.dispatcher = dispatcher;
this.liftedState = liftedState$;
@@ -3500,69 +6315,70 @@ var StoreDevtools = (function () {
StoreDevtools.prototype.error = function (error) { };
StoreDevtools.prototype.complete = function () { };
StoreDevtools.prototype.performAction = function (action) {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].performAction(action));
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].performAction(action));
};
StoreDevtools.prototype.reset = function () {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].reset());
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].reset());
};
StoreDevtools.prototype.rollback = function () {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].rollback());
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].rollback());
};
StoreDevtools.prototype.commit = function () {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].commit());
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].commit());
};
StoreDevtools.prototype.sweep = function () {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].sweep());
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].sweep());
};
StoreDevtools.prototype.toggleAction = function (id) {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].toggleAction(id));
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].toggleAction(id));
};
StoreDevtools.prototype.jumpToState = function (index) {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].jumpToState(index));
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].jumpToState(index));
};
StoreDevtools.prototype.importState = function (nextLiftedState) {
- this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["a" /* StoreDevtoolActions */].importState(nextLiftedState));
+ this.dispatch(__WEBPACK_IMPORTED_MODULE_13__actions__["b" /* StoreDevtoolActions */].importState(nextLiftedState));
};
- StoreDevtools.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
- ];
- /** @nocollapse */
- StoreDevtools.ctorParameters = [
- { type: DevtoolsDispatcher, },
- { type: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Dispatcher"], },
- { type: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"], },
- { type: __WEBPACK_IMPORTED_MODULE_10__extension__["a" /* DevtoolsExtension */], },
- { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Inject"], args: [__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_STATE"],] },] },
- { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Inject"], args: [__WEBPACK_IMPORTED_MODULE_14__config__["a" /* STORE_DEVTOOLS_CONFIG */],] },] },
- ];
return StoreDevtools;
}());
+
+StoreDevtools.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
+];
+/** @nocollapse */
+StoreDevtools.ctorParameters = function () { return [
+ { type: DevtoolsDispatcher, },
+ { type: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Dispatcher"], },
+ { type: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"], },
+ { type: __WEBPACK_IMPORTED_MODULE_10__extension__["a" /* DevtoolsExtension */], },
+ { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Inject"], args: [__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_STATE"],] },] },
+ { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Inject"], args: [__WEBPACK_IMPORTED_MODULE_14__config__["b" /* STORE_DEVTOOLS_CONFIG */],] },] },
+]; };
//# sourceMappingURL=devtools.js.map
/***/ }),
-/* 382 */
+/* 223 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__ = __webpack_require__(1);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty__ = __webpack_require__(417);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__ = __webpack_require__(93);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__ = __webpack_require__(23);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_share__ = __webpack_require__(424);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_share___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_rxjs_operator_share__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_switchMap__ = __webpack_require__(426);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_switchMap___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_rxjs_operator_switchMap__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_takeUntil__ = __webpack_require__(427);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_takeUntil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_rxjs_operator_takeUntil__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__utils__ = __webpack_require__(249);
/* unused harmony export ExtensionActionTypes */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return REDUX_DEVTOOLS_EXTENSION; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DevtoolsExtension; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__ = __webpack_require__(0);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty__ = __webpack_require__(183);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__ = __webpack_require__(45);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__ = __webpack_require__(16);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_share__ = __webpack_require__(118);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rxjs_operator_share___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_rxjs_operator_share__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_switchMap__ = __webpack_require__(195);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rxjs_operator_switchMap___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_rxjs_operator_switchMap__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_takeUntil__ = __webpack_require__(196);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rxjs_operator_takeUntil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_rxjs_operator_takeUntil__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__utils__ = __webpack_require__(131);
@@ -3594,7 +6410,7 @@ var DevtoolsExtension = (function () {
DevtoolsExtension.prototype.createChangesObservable = function () {
var _this = this;
if (!this.devtoolsExtension) {
- return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty__["empty"])();
+ return __WEBPACK_IMPORTED_MODULE_2_rxjs_observable_empty__["empty"]();
}
return new __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__["Observable"](function (subscriber) {
var connection = _this.devtoolsExtension.connect({ instanceId: _this.instanceId });
@@ -3611,12 +6427,12 @@ var DevtoolsExtension = (function () {
// Listen for the stop action
var stop$ = __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__["filter"].call(changes$, function (change) { return change.type === ExtensionActionTypes.STOP; });
// Listen for lifted actions
- var liftedActions$ = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["a" /* applyOperators */])(changes$, [
+ var liftedActions$ = __WEBPACK_IMPORTED_MODULE_8__utils__["a" /* applyOperators */](changes$, [
[__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__["filter"], function (change) { return change.type === ExtensionActionTypes.DISPATCH; }],
[__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__["map"], function (change) { return _this.unwrapAction(change.payload); }]
]);
// Listen for unlifted actions
- var actions$ = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["a" /* applyOperators */])(changes$, [
+ var actions$ = __WEBPACK_IMPORTED_MODULE_8__utils__["a" /* applyOperators */](changes$, [
[__WEBPACK_IMPORTED_MODULE_3_rxjs_operator_filter__["filter"], function (change) { return change.type === ExtensionActionTypes.ACTION; }],
[__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__["map"], function (change) { return _this.unwrapAction(change.payload); }]
]);
@@ -3629,31 +6445,45 @@ var DevtoolsExtension = (function () {
DevtoolsExtension.prototype.unwrapAction = function (action) {
return typeof action === 'string' ? eval("(" + action + ")") : action;
};
- DevtoolsExtension.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
- ];
- /** @nocollapse */
- DevtoolsExtension.ctorParameters = [
- { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Inject"], args: [REDUX_DEVTOOLS_EXTENSION,] },] },
- ];
return DevtoolsExtension;
}());
+
+DevtoolsExtension.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injectable"] },
+];
+/** @nocollapse */
+DevtoolsExtension.ctorParameters = function () { return [
+ { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Inject"], args: [REDUX_DEVTOOLS_EXTENSION,] },] },
+]; };
//# sourceMappingURL=extension.js.map
/***/ }),
-/* 383 */
+/* 224 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return STORE_DEVTOOLS_CONFIG; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return INITIAL_OPTIONS; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+
+var STORE_DEVTOOLS_CONFIG = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["OpaqueToken"]('@ngrx/devtools Options');
+var INITIAL_OPTIONS = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["OpaqueToken"]('@ngrx/devtools Initial Config');
+//# sourceMappingURL=config.js.map
+
+/***/ }),
+/* 225 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_common__ = __webpack_require__(43);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__commander__ = __webpack_require__(590);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__dock__ = __webpack_require__(592);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__dock_monitor__ = __webpack_require__(591);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__actions__ = __webpack_require__(250);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__reducer__ = __webpack_require__(594);
-/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __WEBPACK_IMPORTED_MODULE_6__reducer__["a"]; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DockMonitorModule; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_common__ = __webpack_require__(26);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__commander__ = __webpack_require__(598);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__dock__ = __webpack_require__(600);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__dock_monitor__ = __webpack_require__(601);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__actions__ = __webpack_require__(134);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__reducer__ = __webpack_require__(602);
+/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __WEBPACK_IMPORTED_MODULE_6__reducer__["a"]; });
@@ -3689,16 +6519,16 @@ var DockMonitorModule = (function () {
//# sourceMappingURL=index.js.map
/***/ }),
-/* 384 */
+/* 226 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__ = __webpack_require__(579);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return KNOWN; });
+/* harmony export (immutable) */ __webpack_exports__["d"] = getTypeOf;
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getLabelFor; });
+/* harmony export (immutable) */ __webpack_exports__["b"] = getChildrenFor;
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__ = __webpack_require__(606);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return KNOWN; });
-/* harmony export (immutable) */ __webpack_exports__["c"] = getTypeOf;
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getLabelFor; });
-/* harmony export (immutable) */ __webpack_exports__["a"] = getChildrenFor;
var KNOWN = {
Array: 'array',
@@ -3735,16 +6565,16 @@ var withQuotes = function (val) { return ("\"" + val + "\""); };
var toString = function (val) { return val.toString(); };
var iterableToArray = function (value) { return Array.from(value); };
var labelFactoriesForTypes = (_a = {},
- _a[KNOWN.Array] = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"])(typeIndicator('[]'), lengthLabel('item', 'items'), arrayLength),
- _a[KNOWN.Object] = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"])(typeIndicator('{}'), lengthLabel('key', 'keys'), arrayLength, Object.getOwnPropertyNames),
+ _a[KNOWN.Array] = __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"](typeIndicator('[]'), lengthLabel('item', 'items'), arrayLength),
+ _a[KNOWN.Object] = __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"](typeIndicator('{}'), lengthLabel('key', 'keys'), arrayLength, Object.getOwnPropertyNames),
_a[KNOWN.Null] = typeIdentity(KNOWN.Null),
_a[KNOWN.Undefined] = typeIdentity(KNOWN.Undefined),
_a[KNOWN.Boolean] = function (val) { return val ? 'true' : 'false'; },
_a[KNOWN.Number] = toString,
_a[KNOWN.String] = withQuotes,
- _a[KNOWN.Symbol] = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"])(withQuotes, toString),
+ _a[KNOWN.Symbol] = __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"](withQuotes, toString),
_a[KNOWN.Function] = typeIdentity(KNOWN.Function),
- _a[KNOWN.Iterable] = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"])(typeIndicator('()'), lengthLabel('entry', 'entries'), arrayLength, iterableToArray),
+ _a[KNOWN.Iterable] = __WEBPACK_IMPORTED_MODULE_0__ngrx_core_compose__["compose"](typeIndicator('()'), lengthLabel('entry', 'entries'), arrayLength, iterableToArray),
_a
);
var lookupLabelForType = function (type) { return labelFactoriesForTypes[type]; };
@@ -3772,26 +6602,47 @@ var _a;
//# sourceMappingURL=types.js.map
/***/ }),
-/* 385 */,
-/* 386 */,
-/* 387 */,
-/* 388 */,
-/* 389 */,
-/* 390 */,
-/* 391 */,
-/* 392 */,
-/* 393 */,
-/* 394 */,
-/* 395 */,
-/* 396 */,
-/* 397 */,
-/* 398 */,
-/* 399 */,
-/* 400 */,
-/* 401 */,
-/* 402 */,
-/* 403 */,
-/* 404 */
+/* 227 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__src_actions__ = __webpack_require__(135);
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "routerActions", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["f"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "routerActionTypes", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["e"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "go", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["c"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "replace", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["d"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "search", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["g"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "show", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["h"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "back", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["a"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "forward", function() { return __WEBPACK_IMPORTED_MODULE_0__src_actions__["b"]; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__src_reducer__ = __webpack_require__(612);
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "initialState", function() { return __WEBPACK_IMPORTED_MODULE_1__src_reducer__["a"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "routerReducer", function() { return __WEBPACK_IMPORTED_MODULE_1__src_reducer__["b"]; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__src_router_store_module__ = __webpack_require__(613);
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "setupRouterStore", function() { return __WEBPACK_IMPORTED_MODULE_2__src_router_store_module__["c"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "provideRouterConnector", function() { return __WEBPACK_IMPORTED_MODULE_2__src_router_store_module__["b"]; });
+/* harmony namespace reexport (by provided) */ __webpack_require__.d(__webpack_exports__, "RouterStoreModule", function() { return __WEBPACK_IMPORTED_MODULE_2__src_router_store_module__["a"]; });
+
+
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+/* 228 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var index_1 = __webpack_require__(218);
+exports.dragula = index_1.dragula;
+exports.DragulaDirective = index_1.DragulaDirective;
+exports.DragulaModule = index_1.DragulaModule;
+exports.DragulaService = index_1.DragulaService;
+
+
+/***/ }),
+/* 229 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -3799,58 +6650,1108 @@ var _a;
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
-__export(__webpack_require__(403));
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(230));
+__export(__webpack_require__(617));
/***/ }),
-/* 405 */,
-/* 406 */,
-/* 407 */
+/* 230 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-// a passthrough stream.
-// basically just the most minimal sort of Transform stream.
-// Every written chunk gets output as-is.
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var router_1 = __webpack_require__(20);
+var AddOnComponent = (function () {
+ function AddOnComponent(route) {
+ this.name$ = route
+ .params
+ .select('name');
+ }
+ return AddOnComponent;
+}());
+AddOnComponent = __decorate([
+ core_1.Component({
+ selector: 'add-on',
+ template: __webpack_require__(615),
+ styles: [__webpack_require__(616)],
+ host: {
+ 'class': 'container-fluid'
+ }
+ }),
+ __metadata("design:paramtypes", [router_1.ActivatedRoute])
+], AddOnComponent);
+exports.AddOnComponent = AddOnComponent;
+/***/ }),
+/* 231 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var store_1 = __webpack_require__(5);
+var BehaviorSubject_1 = __webpack_require__(44);
+__webpack_require__(188);
+__webpack_require__(125);
+var actions_1 = __webpack_require__(34);
+var KeymapAddComponent = (function () {
+ function KeymapAddComponent(store) {
+ this.store = store;
+ this.presetsAll$ = store.select(function (appState) { return appState.presetKeymaps; });
+ this.filterExpression$ = new BehaviorSubject_1.BehaviorSubject('');
+ this.presets$ = this.presetsAll$
+ .combineLatest(this.filterExpression$, function (keymaps, filterExpression) {
+ return keymaps.filter(function (keymap) { return keymap.name.toLocaleLowerCase().includes(filterExpression); });
+ })
+ .publishReplay(1)
+ .refCount();
+ }
+ KeymapAddComponent.prototype.filterKeyboards = function (filterExpression) {
+ this.filterExpression$.next(filterExpression);
+ };
+ KeymapAddComponent.prototype.addKeymap = function (keymap) {
+ this.store.dispatch(actions_1.KeymapActions.addKeymap(keymap));
+ };
+ return KeymapAddComponent;
+}());
+KeymapAddComponent = __decorate([
+ core_1.Component({
+ selector: 'keymap-add',
+ template: __webpack_require__(623),
+ styles: [__webpack_require__(624)],
+ host: {
+ 'class': 'container-fluid'
+ }
+ }),
+ __metadata("design:paramtypes", [store_1.Store])
+], KeymapAddComponent);
+exports.KeymapAddComponent = KeymapAddComponent;
+
+
+/***/ }),
+/* 232 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var MacroActions;
+(function (MacroActions) {
+ MacroActions.PREFIX = '[Macro] ';
+ MacroActions.DUPLICATE = MacroActions.PREFIX + 'Duplicate macro';
+ MacroActions.EDIT_NAME = MacroActions.PREFIX + 'Edit macro title';
+ MacroActions.REMOVE = MacroActions.PREFIX + 'Remove macro';
+ MacroActions.ADD = MacroActions.PREFIX + 'Add macro';
+ MacroActions.ADD_ACTION = MacroActions.PREFIX + 'Add macro action';
+ MacroActions.SAVE_ACTION = MacroActions.PREFIX + 'Save macro action';
+ MacroActions.DELETE_ACTION = MacroActions.PREFIX + 'Delete macro action';
+ MacroActions.REORDER_ACTION = MacroActions.PREFIX + 'Reorder macro action';
+ function addMacro() {
+ return {
+ type: MacroActions.ADD
+ };
+ }
+ MacroActions.addMacro = addMacro;
+ function removeMacro(macroId) {
+ return {
+ type: MacroActions.REMOVE,
+ payload: macroId
+ };
+ }
+ MacroActions.removeMacro = removeMacro;
+ function duplicateMacro(macro) {
+ return {
+ type: MacroActions.DUPLICATE,
+ payload: macro
+ };
+ }
+ MacroActions.duplicateMacro = duplicateMacro;
+ function editMacroName(id, name) {
+ return {
+ type: MacroActions.EDIT_NAME,
+ payload: {
+ id: id,
+ name: name
+ }
+ };
+ }
+ MacroActions.editMacroName = editMacroName;
+ function addMacroAction(id, action) {
+ return {
+ type: MacroActions.ADD_ACTION,
+ payload: {
+ id: id,
+ action: action
+ }
+ };
+ }
+ MacroActions.addMacroAction = addMacroAction;
+ function saveMacroAction(id, index, action) {
+ return {
+ type: MacroActions.SAVE_ACTION,
+ payload: {
+ id: id,
+ index: index,
+ action: action
+ }
+ };
+ }
+ MacroActions.saveMacroAction = saveMacroAction;
+ function deleteMacroAction(id, index, action) {
+ return {
+ type: MacroActions.DELETE_ACTION,
+ payload: {
+ id: id,
+ index: index,
+ action: action
+ }
+ };
+ }
+ MacroActions.deleteMacroAction = deleteMacroAction;
+ function reorderMacroAction(id, oldIndex, newIndex) {
+ return {
+ type: MacroActions.REORDER_ACTION,
+ payload: {
+ id: id,
+ oldIndex: oldIndex,
+ newIndex: newIndex
+ }
+ };
+ }
+ MacroActions.reorderMacroAction = reorderMacroAction;
+})(MacroActions = exports.MacroActions || (exports.MacroActions = {}));
+
+
+/***/ }),
+/* 233 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var router_1 = __webpack_require__(20);
+__webpack_require__(234);
+var store_1 = __webpack_require__(5);
+__webpack_require__(191);
+__webpack_require__(73);
+__webpack_require__(21);
+__webpack_require__(125);
+__webpack_require__(56);
+var file_saver_1 = __webpack_require__(625);
+var user_configuration_1 = __webpack_require__(35);
+var KeymapEditComponent = (function () {
+ function KeymapEditComponent(store, route) {
+ this.store = store;
+ this.keymap$ = route
+ .params
+ .select('abbr')
+ .switchMap(function (abbr) { return store.let(user_configuration_1.getKeymap(abbr)); })
+ .publishReplay(1)
+ .refCount();
+ this.deletable$ = store.let(user_configuration_1.getKeymaps())
+ .map(function (keymaps) { return keymaps.length > 1; });
+ }
+ KeymapEditComponent.prototype.downloadKeymap = function () {
+ var _this = this;
+ var exportableJSON$ = this.keymap$
+ .switchMap(function (keymap) { return _this.toExportableJSON(keymap); })
+ .map(function (exportableJSON) { return JSON.stringify(exportableJSON); });
+ this.keymap$
+ .combineLatest(exportableJSON$)
+ .first()
+ .subscribe(function (latest) {
+ var keymap = latest[0];
+ var exportableJSON = latest[1];
+ var fileName = keymap.name + '_keymap.json';
+ file_saver_1.saveAs(new Blob([exportableJSON], { type: 'application/json' }), fileName);
+ });
+ };
+ KeymapEditComponent.prototype.toggleKeyboardSplit = function () {
+ this.keyboardSplit = !this.keyboardSplit;
+ };
+ KeymapEditComponent.prototype.toExportableJSON = function (keymap) {
+ return this.store
+ .let(user_configuration_1.getUserConfiguration())
+ .first()
+ .map(function (userConfiguration) {
+ return {
+ site: 'https://ultimatehackingkeyboard.com',
+ description: 'Ultimate Hacking Keyboard keymap',
+ keyboardModel: 'UHK60',
+ dataModelVersion: userConfiguration.dataModelVersion,
+ objectType: 'keymap',
+ objectValue: keymap.toJsonObject()
+ };
+ });
+ };
+ return KeymapEditComponent;
+}());
+__decorate([
+ core_1.HostListener('window:keydown.alt.s', ['$event']),
+ __metadata("design:type", Function),
+ __metadata("design:paramtypes", []),
+ __metadata("design:returntype", void 0)
+], KeymapEditComponent.prototype, "toggleKeyboardSplit", null);
+KeymapEditComponent = __decorate([
+ core_1.Component({
+ selector: 'keymap-edit',
+ template: __webpack_require__(644),
+ styles: [__webpack_require__(645)],
+ host: {
+ 'class': 'container-fluid'
+ }
+ }),
+ __metadata("design:paramtypes", [store_1.Store,
+ router_1.ActivatedRoute])
+], KeymapEditComponent);
+exports.KeymapEditComponent = KeymapEditComponent;
+
+
+/***/ }),
+/* 234 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var Observable_1 = __webpack_require__(0);
+var select_1 = __webpack_require__(133);
+Observable_1.Observable.prototype.select = select_1.select;
+
+
+/***/ }),
+/* 235 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var LongPressAction;
+(function (LongPressAction) {
+ LongPressAction[LongPressAction["leftCtrl"] = 0] = "leftCtrl";
+ LongPressAction[LongPressAction["leftShift"] = 1] = "leftShift";
+ LongPressAction[LongPressAction["leftAlt"] = 2] = "leftAlt";
+ LongPressAction[LongPressAction["leftSuper"] = 3] = "leftSuper";
+ LongPressAction[LongPressAction["rightCtrl"] = 4] = "rightCtrl";
+ LongPressAction[LongPressAction["rightShift"] = 5] = "rightShift";
+ LongPressAction[LongPressAction["rightAlt"] = 6] = "rightAlt";
+ LongPressAction[LongPressAction["rightSuper"] = 7] = "rightSuper";
+ LongPressAction[LongPressAction["mod"] = 8] = "mod";
+ LongPressAction[LongPressAction["fn"] = 9] = "fn";
+ LongPressAction[LongPressAction["mouse"] = 10] = "mouse";
+})(LongPressAction = exports.LongPressAction || (exports.LongPressAction = {}));
+
+
+/***/ }),
+/* 236 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var module_1 = __webpack_require__(237);
+var Layer = (function () {
+ function Layer(layers) {
+ if (!layers) {
+ return;
+ }
+ this.modules = layers.modules.map(function (module) { return new module_1.Module(module); });
+ }
+ Layer.prototype.fromJsonObject = function (jsonObject, macros) {
+ this.modules = jsonObject.modules.map(function (module) { return new module_1.Module().fromJsonObject(module, macros); });
+ return this;
+ };
+ Layer.prototype.fromBinary = function (buffer, macros) {
+ this.modules = buffer.readArray(function (uhkBuffer) {
+ return new module_1.Module().fromBinary(uhkBuffer, macros);
+ });
+ return this;
+ };
+ Layer.prototype.toJsonObject = function (macros) {
+ return {
+ modules: this.modules.map(function (module) { return module.toJsonObject(macros); })
+ };
+ };
+ Layer.prototype.toBinary = function (buffer, macros) {
+ buffer.writeArray(this.modules, function (uhkBuffer, module) {
+ module.toBinary(uhkBuffer, macros);
+ });
+ };
+ Layer.prototype.toString = function () {
+ return "";
+ };
+ Layer.prototype.renameKeymap = function (oldAbbr, newAbbr) {
+ var _this = this;
+ var modules;
+ var moduleModified = false;
+ this.modules.forEach(function (module, index) {
+ var newModule = module.renameKeymap(oldAbbr, newAbbr);
+ if (newModule !== module) {
+ if (!moduleModified) {
+ modules = _this.modules.slice();
+ moduleModified = true;
+ }
+ modules[index] = newModule;
+ }
+ });
+ if (moduleModified) {
+ var newLayer = Object.assign(new Layer(), this);
+ newLayer.modules = modules;
+ return newLayer;
+ }
+ return this;
+ };
+ return Layer;
+}());
+exports.Layer = Layer;
+
+
+/***/ }),
+/* 237 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var assert_1 = __webpack_require__(17);
+var key_action_1 = __webpack_require__(14);
+var PointerRole;
+(function (PointerRole) {
+ PointerRole[PointerRole["none"] = 0] = "none";
+ PointerRole[PointerRole["move"] = 1] = "move";
+ PointerRole[PointerRole["scroll"] = 2] = "scroll";
+})(PointerRole || (PointerRole = {}));
+var Module = (function () {
+ function Module(other) {
+ if (!other) {
+ return;
+ }
+ this.id = other.id;
+ this.keyActions = other.keyActions.map(function (keyAction) { return key_action_1.Helper.createKeyAction(keyAction); });
+ this.pointerRole = other.pointerRole;
+ }
+ Module.prototype.fromJsonObject = function (jsonObject, macros) {
+ this.id = jsonObject.id;
+ this.pointerRole = PointerRole[jsonObject.pointerRole];
+ this.keyActions = jsonObject.keyActions.map(function (keyAction) {
+ return key_action_1.Helper.createKeyAction(keyAction, macros);
+ });
+ return this;
+ };
+ Module.prototype.fromBinary = function (buffer, macros) {
+ this.id = buffer.readUInt8();
+ this.pointerRole = buffer.readUInt8();
+ var keyActionsLength = buffer.readCompactLength();
+ this.keyActions = [];
+ for (var i = 0; i < keyActionsLength; ++i) {
+ this.keyActions.push(key_action_1.Helper.createKeyAction(buffer, macros));
+ }
+ return this;
+ };
+ Module.prototype.toJsonObject = function (macros) {
+ return {
+ id: this.id,
+ pointerRole: PointerRole[this.pointerRole],
+ keyActions: this.keyActions.map(function (keyAction) {
+ if (keyAction && (macros || !(keyAction instanceof key_action_1.PlayMacroAction || keyAction instanceof key_action_1.SwitchKeymapAction))) {
+ return keyAction.toJsonObject(macros);
+ }
+ })
+ };
+ };
+ Module.prototype.toBinary = function (buffer, macros) {
+ buffer.writeUInt8(this.id);
+ buffer.writeUInt8(this.pointerRole);
+ var noneAction = new key_action_1.NoneAction();
+ var keyActions = this.keyActions.map(function (keyAction) {
+ if (keyAction) {
+ return keyAction;
+ }
+ return noneAction;
+ });
+ buffer.writeArray(keyActions, function (uhkBuffer, keyAction) {
+ keyAction.toBinary(uhkBuffer, macros);
+ });
+ };
+ Module.prototype.toString = function () {
+ return "";
+ };
+ Module.prototype.renameKeymap = function (oldAbbr, newAbbr) {
+ var _this = this;
+ var keyActions;
+ var keyActionModified = false;
+ this.keyActions.forEach(function (keyAction, index) {
+ if (!keyAction) {
+ return;
+ }
+ var newKeyAction = keyAction.renameKeymap(oldAbbr, newAbbr);
+ if (newKeyAction !== keyAction) {
+ if (!keyActionModified) {
+ keyActions = _this.keyActions.slice();
+ keyActionModified = true;
+ }
+ keyActions[index] = newKeyAction;
+ }
+ });
+ if (keyActionModified) {
+ var newModule = Object.assign(new Module(), this);
+ newModule.keyActions = keyActions;
+ return newModule;
+ }
+ return this;
+ };
+ return Module;
+}());
+__decorate([
+ assert_1.assertUInt8,
+ __metadata("design:type", Number)
+], Module.prototype, "id", void 0);
+__decorate([
+ assert_1.assertEnum(PointerRole),
+ __metadata("design:type", Number)
+], Module.prototype, "pointerRole", void 0);
+exports.Module = Module;
+
+
+/***/ }),
+/* 238 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(Buffer, process) {
+Object.defineProperty(exports, "__esModule", { value: true });
+var UhkBuffer = (function () {
+ function UhkBuffer() {
+ this._enableDump = false;
+ this.offset = 0;
+ this.bytesToBacktrack = 0;
+ this.buffer = new Buffer(UhkBuffer.eepromSize);
+ this.buffer.fill(0);
+ }
+ UhkBuffer.simpleElementWriter = function (buffer, element) {
+ element.toBinary(buffer); // TODO: Remove any
+ };
+ UhkBuffer.prototype.readInt8 = function () {
+ var value = this.buffer.readInt8(this.offset);
+ this.dump("i8(" + value + ")");
+ this.bytesToBacktrack = 1;
+ this.offset += this.bytesToBacktrack;
+ return value;
+ };
+ UhkBuffer.prototype.writeInt8 = function (value) {
+ this.dump("i8(" + value + ")");
+ this.buffer.writeInt8(value, this.offset);
+ this.offset += 1;
+ };
+ UhkBuffer.prototype.readUInt8 = function () {
+ var value = this.buffer.readUInt8(this.offset);
+ this.dump("u8(" + value + ")");
+ this.bytesToBacktrack = 1;
+ this.offset += this.bytesToBacktrack;
+ return value;
+ };
+ UhkBuffer.prototype.writeUInt8 = function (value) {
+ this.dump("u8(" + value + ")");
+ this.buffer.writeUInt8(value, this.offset);
+ this.offset += 1;
+ };
+ UhkBuffer.prototype.readInt16 = function () {
+ var value = this.buffer.readInt16LE(this.offset);
+ this.dump("i16(" + value + ")");
+ this.bytesToBacktrack = 2;
+ this.offset += this.bytesToBacktrack;
+ return value;
+ };
+ UhkBuffer.prototype.writeInt16 = function (value) {
+ this.dump("i16(" + value + ")");
+ this.buffer.writeInt16LE(value, this.offset);
+ this.offset += 2;
+ };
+ UhkBuffer.prototype.readUInt16 = function () {
+ var value = this.buffer.readUInt16LE(this.offset);
+ this.dump("u16(" + value + ")");
+ this.bytesToBacktrack = 2;
+ this.offset += this.bytesToBacktrack;
+ return value;
+ };
+ UhkBuffer.prototype.writeUInt16 = function (value) {
+ this.dump("u16(" + value + ")");
+ this.buffer.writeUInt16LE(value, this.offset);
+ this.offset += 2;
+ };
+ UhkBuffer.prototype.readInt32 = function () {
+ var value = this.buffer.readInt32LE(this.offset);
+ this.dump("i32(" + value + ")");
+ this.bytesToBacktrack = 4;
+ this.offset += this.bytesToBacktrack;
+ return value;
+ };
+ UhkBuffer.prototype.writeInt32 = function (value) {
+ this.dump("i32(" + value + ")");
+ this.buffer.writeInt32LE(value, this.offset);
+ this.offset += 4;
+ };
+ UhkBuffer.prototype.readUInt32 = function () {
+ var value = this.buffer.readUInt32LE(this.offset);
+ this.dump("u32(" + value + ")");
+ this.bytesToBacktrack = 4;
+ this.offset += this.bytesToBacktrack;
+ return value;
+ };
+ UhkBuffer.prototype.writeUInt32 = function (value) {
+ this.dump("u32(" + value + ")");
+ this.buffer.writeUInt32LE(value, this.offset);
+ this.offset += 4;
+ };
+ UhkBuffer.prototype.readCompactLength = function () {
+ var length = this.readUInt8();
+ if (length === UhkBuffer.longCompactLengthPrefix) {
+ length = this.readUInt16();
+ }
+ return length;
+ };
+ UhkBuffer.prototype.writeCompactLength = function (length) {
+ if (length >= UhkBuffer.longCompactLengthPrefix) {
+ this.writeUInt8(UhkBuffer.longCompactLengthPrefix);
+ this.writeUInt16(length);
+ }
+ else {
+ this.writeUInt8(length);
+ }
+ };
+ UhkBuffer.prototype.readString = function () {
+ var stringByteLength = this.readCompactLength();
+ var str = this.buffer.toString(UhkBuffer.stringEncoding, this.offset, this.offset + stringByteLength);
+ this.dump(UhkBuffer.stringEncoding + "(" + str + ")");
+ this.bytesToBacktrack = stringByteLength;
+ this.offset += stringByteLength;
+ return str;
+ };
+ UhkBuffer.prototype.writeString = function (str) {
+ var stringByteLength = Buffer.byteLength(str, UhkBuffer.stringEncoding);
+ if (stringByteLength > UhkBuffer.maxCompactLength) {
+ throw "Cannot serialize string: " + stringByteLength + " bytes is larger\n than the maximum allowed length of " + UhkBuffer.maxCompactLength + " bytes";
+ }
+ this.writeCompactLength(stringByteLength);
+ this.dump(UhkBuffer.stringEncoding + "(" + str + ")");
+ this.buffer.write(str, this.offset, stringByteLength, UhkBuffer.stringEncoding);
+ this.offset += stringByteLength;
+ };
+ UhkBuffer.prototype.readBoolean = function () {
+ return this.readUInt8() !== 0;
+ };
+ UhkBuffer.prototype.writeBoolean = function (bool) {
+ this.writeUInt8(bool ? 1 : 0);
+ };
+ UhkBuffer.prototype.readArray = function (elementReader) {
+ var array = [];
+ var length = this.readCompactLength();
+ for (var i = 0; i < length; ++i) {
+ array.push(elementReader(this, i));
+ }
+ return array;
+ };
+ UhkBuffer.prototype.writeArray = function (array, elementWriter) {
+ if (elementWriter === void 0) { elementWriter = UhkBuffer.simpleElementWriter; }
+ var length = array.length;
+ this.writeCompactLength(length);
+ for (var i = 0; i < length; ++i) {
+ elementWriter(this, array[i], i);
+ }
+ };
+ UhkBuffer.prototype.backtrack = function () {
+ this.offset -= this.bytesToBacktrack;
+ this.bytesToBacktrack = 0;
+ };
+ UhkBuffer.prototype.getBufferContent = function () {
+ return this.buffer.slice(0, this.offset);
+ };
+ Object.defineProperty(UhkBuffer.prototype, "enableDump", {
+ get: function () {
+ return this._enableDump;
+ },
+ set: function (value) {
+ if (value) {
+ UhkBuffer.isFirstElementToDump = true;
+ }
+ this._enableDump = value;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ UhkBuffer.prototype.dump = function (value) {
+ if (!this.enableDump) {
+ return;
+ }
+ if (!UhkBuffer.isFirstElementToDump) {
+ process.stdout.write(', ');
+ }
+ process.stdout.write(value);
+ if (UhkBuffer.isFirstElementToDump) {
+ UhkBuffer.isFirstElementToDump = false;
+ }
+ };
+ return UhkBuffer;
+}());
+UhkBuffer.eepromSize = 32 * 1024;
+UhkBuffer.maxCompactLength = 0xFFFF;
+UhkBuffer.longCompactLengthPrefix = 0xFF;
+UhkBuffer.stringEncoding = 'utf8';
+UhkBuffer.isFirstElementToDump = false;
+exports.UhkBuffer = UhkBuffer;
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(75).Buffer, __webpack_require__(38)))
+
+/***/ }),
+/* 239 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = __webpack_require__(57);
+var PREFIX = '[user-config] ';
+// tslint:disable-next-line:variable-name
+exports.ActionTypes = {
+ LOAD_USER_CONFIG: util_1.type(PREFIX + 'Load User Config'),
+ LOAD_USER_CONFIG_SUCCESS: util_1.type(PREFIX + 'Load User Config Success'),
+ SAVE_USER_CONFIG_SUCCESS: util_1.type(PREFIX + 'Save User Config Success')
+};
+var LoadUserConfigAction = (function () {
+ function LoadUserConfigAction() {
+ this.type = exports.ActionTypes.LOAD_USER_CONFIG;
+ }
+ return LoadUserConfigAction;
+}());
+exports.LoadUserConfigAction = LoadUserConfigAction;
+var LoadUserConfigSuccessAction = (function () {
+ function LoadUserConfigSuccessAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.LOAD_USER_CONFIG_SUCCESS;
+ }
+ return LoadUserConfigSuccessAction;
+}());
+exports.LoadUserConfigSuccessAction = LoadUserConfigSuccessAction;
+var SaveUserConfigSuccessAction = (function () {
+ function SaveUserConfigSuccessAction() {
+ this.type = exports.ActionTypes.SAVE_USER_CONFIG_SUCCESS;
+ }
+ return SaveUserConfigSuccessAction;
+}());
+exports.SaveUserConfigSuccessAction = SaveUserConfigSuccessAction;
+
+
+/***/ }),
+/* 240 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var router_1 = __webpack_require__(20);
+var store_1 = __webpack_require__(5);
+var actions_1 = __webpack_require__(34);
+var user_configuration_1 = __webpack_require__(35);
+var MacroEditComponent = (function () {
+ function MacroEditComponent(store, route) {
+ var _this = this;
+ this.store = store;
+ this.route = route;
+ this.subscription = route
+ .params
+ .select('id')
+ .switchMap(function (id) { return store.let(user_configuration_1.getMacro(+id)); })
+ .subscribe(function (macro) {
+ _this.macro = macro;
+ });
+ this.isNew = this.route.snapshot.params['empty'] === 'new';
+ }
+ MacroEditComponent.prototype.ngOnDestroy = function () {
+ this.subscription.unsubscribe();
+ };
+ MacroEditComponent.prototype.addAction = function (macroId, action) {
+ this.store.dispatch(actions_1.MacroActions.addMacroAction(macroId, action));
+ };
+ MacroEditComponent.prototype.editAction = function (macroId, index, action) {
+ this.store.dispatch(actions_1.MacroActions.saveMacroAction(macroId, index, action));
+ };
+ MacroEditComponent.prototype.deleteAction = function (macroId, index, action) {
+ this.store.dispatch(actions_1.MacroActions.deleteMacroAction(macroId, index, action));
+ };
+ MacroEditComponent.prototype.reorderAction = function (macroId, oldIndex, newIndex) {
+ this.store.dispatch(actions_1.MacroActions.reorderMacroAction(macroId, oldIndex, newIndex));
+ };
+ return MacroEditComponent;
+}());
+MacroEditComponent = __decorate([
+ core_1.Component({
+ selector: 'macro-edit',
+ template: __webpack_require__(653),
+ styles: [__webpack_require__(654)],
+ host: {
+ 'class': 'container-fluid'
+ }
+ }),
+ __metadata("design:paramtypes", [store_1.Store, router_1.ActivatedRoute])
+], MacroEditComponent);
+exports.MacroEditComponent = MacroEditComponent;
+
+
+/***/ }),
+/* 241 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var delay_1 = __webpack_require__(672);
+exports.MacroDelayTabComponent = delay_1.MacroDelayTabComponent;
+var key_1 = __webpack_require__(676);
+exports.MacroKeyTabComponent = key_1.MacroKeyTabComponent;
+var mouse_1 = __webpack_require__(706);
+exports.MacroMouseTabComponent = mouse_1.MacroMouseTabComponent;
+var text_1 = __webpack_require__(710);
+exports.MacroTextTabComponent = text_1.MacroTextTabComponent;
+
+
+/***/ }),
+/* 242 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(719));
+
+
+/***/ }),
+/* 243 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(244));
+__export(__webpack_require__(734));
+
+
+/***/ }),
+/* 244 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var store_1 = __webpack_require__(5);
+var index_1 = __webpack_require__(57);
+var store_2 = __webpack_require__(143);
+var auto_update_settings_1 = __webpack_require__(145);
+var SettingsComponent = (function () {
+ function SettingsComponent(store) {
+ this.store = store;
+ this.runInElectron = index_1.runInElectron();
+ // TODO: From where do we get the version number? The electron gives back in main process, but the web...
+ this.version = '1.0.0';
+ this.autoUpdateSettings$ = store.select(store_2.getAutoUpdateSettings);
+ this.checkingForUpdate$ = store.select(store_2.getCheckingForUpdate);
+ }
+ SettingsComponent.prototype.toogleCheckForUpdateOnStartUp = function (value) {
+ this.store.dispatch(new auto_update_settings_1.ToggleCheckForUpdateOnStartupAction(value));
+ };
+ SettingsComponent.prototype.toogleUsePreReleaseUpdate = function (value) {
+ this.store.dispatch(new auto_update_settings_1.TogglePreReleaseFlagAction(value));
+ };
+ SettingsComponent.prototype.checkForUpdate = function () {
+ this.store.dispatch(new auto_update_settings_1.CheckForUpdateNowAction());
+ };
+ return SettingsComponent;
+}());
+SettingsComponent = __decorate([
+ core_1.Component({
+ selector: 'settings',
+ template: __webpack_require__(732),
+ styles: [__webpack_require__(733)],
+ host: {
+ 'class': 'container-fluid'
+ }
+ }),
+ __metadata("design:paramtypes", [store_1.Store])
+], SettingsComponent);
+exports.SettingsComponent = SettingsComponent;
+
+
+/***/ }),
+/* 245 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var module_1 = __webpack_require__(246);
+var keyboard_layout_enum_1 = __webpack_require__(745);
+var SvgModuleProviderService = (function () {
+ function SvgModuleProviderService() {
+ }
+ SvgModuleProviderService.prototype.getSvgModules = function (layout) {
+ if (layout === void 0) { layout = keyboard_layout_enum_1.KeyboardLayout.ANSI; }
+ return [this.getRightModule(), this.getLeftModule(layout)];
+ };
+ SvgModuleProviderService.prototype.getLeftModule = function (layout) {
+ if (layout === void 0) { layout = keyboard_layout_enum_1.KeyboardLayout.ANSI; }
+ if (layout === keyboard_layout_enum_1.KeyboardLayout.ISO) {
+ if (!this.isoLeft) {
+ this.isoLeft = new module_1.SvgModule(__webpack_require__(746).svg);
+ }
+ return this.isoLeft;
+ }
+ if (!this.ansiLeft) {
+ this.ansiLeft = new module_1.SvgModule(__webpack_require__(747).svg);
+ }
+ return this.ansiLeft;
+ };
+ SvgModuleProviderService.prototype.getRightModule = function () {
+ if (!this.right) {
+ this.right = new module_1.SvgModule(__webpack_require__(748).svg);
+ }
+ return this.right;
+ };
+ return SvgModuleProviderService;
+}());
+SvgModuleProviderService = __decorate([
+ core_1.Injectable()
+], SvgModuleProviderService);
+exports.SvgModuleProviderService = SvgModuleProviderService;
+
+
+/***/ }),
+/* 246 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(741));
+__export(__webpack_require__(744));
+
+
+/***/ }),
+/* 247 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var keymap_edit_component_1 = __webpack_require__(233);
+exports.KeymapEditComponent = keymap_edit_component_1.KeymapEditComponent;
+var keymap_edit_guard_service_1 = __webpack_require__(805);
+exports.KeymapEditGuard = keymap_edit_guard_service_1.KeymapEditGuard;
+
+
+/***/ }),
+/* 248 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var user_configuration_1 = __webpack_require__(137);
+var DefaultUserConfigurationService = (function () {
+ function DefaultUserConfigurationService() {
+ this._defaultConfig = new user_configuration_1.UserConfiguration()
+ .fromJsonObject(__webpack_require__(822));
+ }
+ DefaultUserConfigurationService.prototype.getDefault = function () {
+ return this._defaultConfig;
+ };
+ return DefaultUserConfigurationService;
+}());
+DefaultUserConfigurationService = __decorate([
+ core_1.Injectable(),
+ __metadata("design:paramtypes", [])
+], DefaultUserConfigurationService);
+exports.DefaultUserConfigurationService = DefaultUserConfigurationService;
+
+
+/***/ }),
+/* 249 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var NotificationType;
+(function (NotificationType) {
+ NotificationType[NotificationType["Default"] = 0] = "Default";
+ NotificationType[NotificationType["Success"] = 1] = "Success";
+ NotificationType[NotificationType["Error"] = 2] = "Error";
+ NotificationType[NotificationType["Warning"] = 3] = "Warning";
+ NotificationType[NotificationType["Info"] = 4] = "Info";
+})(NotificationType = exports.NotificationType || (exports.NotificationType = {}));
+
+
+/***/ }),
+/* 250 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = __webpack_require__(57);
+var PREFIX = '[app] ';
+// tslint:disable-next-line:variable-name
+exports.ActionTypes = {
+ APP_BOOTSRAPPED: util_1.type(PREFIX + 'bootstrapped'),
+ APP_STARTED: util_1.type(PREFIX + 'started'),
+ APP_SHOW_NOTIFICATION: util_1.type(PREFIX + 'show notification')
+};
+var AppBootsrappedAction = (function () {
+ function AppBootsrappedAction() {
+ this.type = exports.ActionTypes.APP_BOOTSRAPPED;
+ }
+ return AppBootsrappedAction;
+}());
+exports.AppBootsrappedAction = AppBootsrappedAction;
+var AppStartedAction = (function () {
+ function AppStartedAction() {
+ this.type = exports.ActionTypes.APP_STARTED;
+ }
+ return AppStartedAction;
+}());
+exports.AppStartedAction = AppStartedAction;
+var ShowNotificationAction = (function () {
+ function ShowNotificationAction(payload) {
+ this.payload = payload;
+ this.type = exports.ActionTypes.APP_SHOW_NOTIFICATION;
+ }
+ return ShowNotificationAction;
+}());
+exports.ShowNotificationAction = ShowNotificationAction;
+
+
+/***/ }),
+/* 251 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
-module.exports = PassThrough;
-var Transform = __webpack_require__(270);
/**/
-var util = __webpack_require__(120);
-util.inherits = __webpack_require__(92);
+
+var processNextTick = __webpack_require__(101);
/**/
-util.inherits(PassThrough, Transform);
-
-function PassThrough(options) {
- if (!(this instanceof PassThrough)) return new PassThrough(options);
-
- Transform.call(this, options);
-}
-
-PassThrough.prototype._transform = function (chunk, encoding, cb) {
- cb(null, chunk);
-};
-
-/***/ }),
-/* 408 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(process) {
-
module.exports = Readable;
/**/
-var processNextTick = __webpack_require__(268);
-/**/
-
-/**/
-var isArray = __webpack_require__(401);
+var isArray = __webpack_require__(220);
/**/
/**/
@@ -3860,7 +7761,7 @@ var Duplex;
Readable.ReadableState = ReadableState;
/**/
-var EE = __webpack_require__(175).EventEmitter;
+var EE = __webpack_require__(147).EventEmitter;
var EElistenerCount = function (emitter, type) {
return emitter.listeners(type).length;
@@ -3868,28 +7769,29 @@ var EElistenerCount = function (emitter, type) {
/**/
/**/
-var Stream;
-(function () {
- try {
- Stream = __webpack_require__(191);
- } catch (_) {} finally {
- if (!Stream) Stream = __webpack_require__(175).EventEmitter;
- }
-})();
+var Stream = __webpack_require__(252);
/**/
-var Buffer = __webpack_require__(56).Buffer;
+// TODO(bmeurer): Change this back to const once hole checks are
+// properly optimized away early in Ignition+TurboFan.
/**/
-var bufferShim = __webpack_require__(251);
+var Buffer = __webpack_require__(149).Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
/**/
/**/
-var util = __webpack_require__(120);
-util.inherits = __webpack_require__(92);
+var util = __webpack_require__(76);
+util.inherits = __webpack_require__(58);
/**/
/**/
-var debugUtil = __webpack_require__(1127);
+var debugUtil = __webpack_require__(834);
var debug = void 0;
if (debugUtil && debugUtil.debuglog) {
debug = debugUtil.debuglog('stream');
@@ -3898,11 +7800,14 @@ if (debugUtil && debugUtil.debuglog) {
}
/**/
-var BufferList = __webpack_require__(757);
+var BufferList = __webpack_require__(835);
+var destroyImpl = __webpack_require__(253);
var StringDecoder;
util.inherits(Readable, Stream);
+var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+
function prependListener(emitter, event, fn) {
// Sadly this is not cacheable as some libraries bundle their own
// event emitter implementation with them.
@@ -3918,7 +7823,7 @@ function prependListener(emitter, event, fn) {
}
function ReadableState(options, stream) {
- Duplex = Duplex || __webpack_require__(78);
+ Duplex = Duplex || __webpack_require__(50);
options = options || {};
@@ -3935,7 +7840,7 @@ function ReadableState(options, stream) {
this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
// cast to ints.
- this.highWaterMark = ~ ~this.highWaterMark;
+ this.highWaterMark = Math.floor(this.highWaterMark);
// A linked list is used to store data chunks instead of an array because the
// linked list can remove elements from the beginning faster than
@@ -3949,10 +7854,10 @@ function ReadableState(options, stream) {
this.endEmitted = false;
this.reading = false;
- // a flag to be able to tell if the onwrite cb is called immediately,
- // or on a later tick. We set this to true at first, because any
- // actions that shouldn't happen until "later" should generally also
- // not happen before the first write call.
+ // a flag to be able to tell if the event 'readable'/'data' is emitted
+ // immediately, or on a later tick. We set this to true at first, because
+ // any actions that shouldn't happen until "later" should generally also
+ // not happen before the first read call.
this.sync = true;
// whenever we return null, then we set a flag to say
@@ -3962,15 +7867,14 @@ function ReadableState(options, stream) {
this.readableListening = false;
this.resumeScheduled = false;
+ // has it been destroyed
+ this.destroyed = false;
+
// Crypto is kind of old and crusty. Historically, its default string
// encoding is 'binary' so we have to make this configurable.
// Everything else in the universe uses 'utf8', though.
this.defaultEncoding = options.defaultEncoding || 'utf8';
- // when piping, we only care about 'readable' events that happen
- // after read()ing all the bytes and not getting any pushback.
- this.ranOut = false;
-
// the number of writers that are awaiting a drain event in .pipe()s
this.awaitDrain = 0;
@@ -3980,14 +7884,14 @@ function ReadableState(options, stream) {
this.decoder = null;
this.encoding = null;
if (options.encoding) {
- if (!StringDecoder) StringDecoder = __webpack_require__(442).StringDecoder;
+ if (!StringDecoder) StringDecoder = __webpack_require__(254).StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
- Duplex = Duplex || __webpack_require__(78);
+ Duplex = Duplex || __webpack_require__(50);
if (!(this instanceof Readable)) return new Readable(options);
@@ -3996,87 +7900,129 @@ function Readable(options) {
// legacy
this.readable = true;
- if (options && typeof options.read === 'function') this._read = options.read;
+ if (options) {
+ if (typeof options.read === 'function') this._read = options.read;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ }
Stream.call(this);
}
+Object.defineProperty(Readable.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._readableState) {
+ return;
+ }
+
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ }
+});
+
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function (err, cb) {
+ this.push(null);
+ cb(err);
+};
+
// Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
Readable.prototype.push = function (chunk, encoding) {
var state = this._readableState;
+ var skipChunkCheck;
- if (!state.objectMode && typeof chunk === 'string') {
- encoding = encoding || state.defaultEncoding;
- if (encoding !== state.encoding) {
- chunk = bufferShim.from(chunk, encoding);
- encoding = '';
+ if (!state.objectMode) {
+ if (typeof chunk === 'string') {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = Buffer.from(chunk, encoding);
+ encoding = '';
+ }
+ skipChunkCheck = true;
}
+ } else {
+ skipChunkCheck = true;
}
- return readableAddChunk(this, state, chunk, encoding, false);
+ return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
};
// Unshift should *always* be something directly out of read()
Readable.prototype.unshift = function (chunk) {
- var state = this._readableState;
- return readableAddChunk(this, state, chunk, '', true);
+ return readableAddChunk(this, chunk, null, true, false);
};
-Readable.prototype.isPaused = function () {
- return this._readableState.flowing === false;
-};
-
-function readableAddChunk(stream, state, chunk, encoding, addToFront) {
- var er = chunkInvalid(state, chunk);
- if (er) {
- stream.emit('error', er);
- } else if (chunk === null) {
+function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+ var state = stream._readableState;
+ if (chunk === null) {
state.reading = false;
onEofChunk(stream, state);
- } else if (state.objectMode || chunk && chunk.length > 0) {
- if (state.ended && !addToFront) {
- var e = new Error('stream.push() after EOF');
- stream.emit('error', e);
- } else if (state.endEmitted && addToFront) {
- var _e = new Error('stream.unshift() after end event');
- stream.emit('error', _e);
- } else {
- var skipAdd;
- if (state.decoder && !addToFront && !encoding) {
- chunk = state.decoder.write(chunk);
- skipAdd = !state.objectMode && chunk.length === 0;
+ } else {
+ var er;
+ if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
+ chunk = _uint8ArrayToBuffer(chunk);
}
- if (!addToFront) state.reading = false;
-
- // Don't add to the buffer if we've decoded to an empty string chunk and
- // we're not in object mode
- if (!skipAdd) {
- // if we want the data now, just emit it.
- if (state.flowing && state.length === 0 && !state.sync) {
- stream.emit('data', chunk);
- stream.read(0);
+ if (addToFront) {
+ if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
+ } else if (state.ended) {
+ stream.emit('error', new Error('stream.push() after EOF'));
+ } else {
+ state.reading = false;
+ if (state.decoder && !encoding) {
+ chunk = state.decoder.write(chunk);
+ if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
} else {
- // update the buffer info.
- state.length += state.objectMode ? 1 : chunk.length;
- if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
-
- if (state.needReadable) emitReadable(stream);
+ addChunk(stream, state, chunk, false);
}
}
-
- maybeReadMore(stream, state);
+ } else if (!addToFront) {
+ state.reading = false;
}
- } else if (!addToFront) {
- state.reading = false;
}
return needMoreData(state);
}
+function addChunk(stream, state, chunk, addToFront) {
+ if (state.flowing && state.length === 0 && !state.sync) {
+ stream.emit('data', chunk);
+ stream.read(0);
+ } else {
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+
+ if (state.needReadable) emitReadable(stream);
+ }
+ maybeReadMore(stream, state);
+}
+
+function chunkInvalid(state, chunk) {
+ var er;
+ if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes. This is to work around cases where hwm=0,
@@ -4088,9 +8034,13 @@ function needMoreData(state) {
return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
}
+Readable.prototype.isPaused = function () {
+ return this._readableState.flowing === false;
+};
+
// backwards compatibility.
Readable.prototype.setEncoding = function (enc) {
- if (!StringDecoder) StringDecoder = __webpack_require__(442).StringDecoder;
+ if (!StringDecoder) StringDecoder = __webpack_require__(254).StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;
@@ -4236,14 +8186,6 @@ Readable.prototype.read = function (n) {
return ret;
};
-function chunkInvalid(state, chunk) {
- var er = null;
- if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
- er = new TypeError('Invalid non-string/buffer chunk');
- }
- return er;
-}
-
function onEofChunk(stream, state) {
if (state.ended) return;
if (state.decoder) {
@@ -4331,14 +8273,17 @@ Readable.prototype.pipe = function (dest, pipeOpts) {
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
- var endFn = doEnd ? onend : cleanup;
+ var endFn = doEnd ? onend : unpipe;
if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);
dest.on('unpipe', onunpipe);
- function onunpipe(readable) {
+ function onunpipe(readable, unpipeInfo) {
debug('onunpipe');
if (readable === src) {
- cleanup();
+ if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+ unpipeInfo.hasUnpiped = true;
+ cleanup();
+ }
}
}
@@ -4364,7 +8309,7 @@ Readable.prototype.pipe = function (dest, pipeOpts) {
dest.removeListener('error', onerror);
dest.removeListener('unpipe', onunpipe);
src.removeListener('end', onend);
- src.removeListener('end', cleanup);
+ src.removeListener('end', unpipe);
src.removeListener('data', ondata);
cleanedUp = true;
@@ -4457,6 +8402,7 @@ function pipeOnDrain(src) {
Readable.prototype.unpipe = function (dest) {
var state = this._readableState;
+ var unpipeInfo = { hasUnpiped: false };
// if we're not piping anywhere, then do nothing.
if (state.pipesCount === 0) return this;
@@ -4472,7 +8418,7 @@ Readable.prototype.unpipe = function (dest) {
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
- if (dest) dest.emit('unpipe', this);
+ if (dest) dest.emit('unpipe', this, unpipeInfo);
return this;
}
@@ -4487,7 +8433,7 @@ Readable.prototype.unpipe = function (dest) {
state.flowing = false;
for (var i = 0; i < len; i++) {
- dests[i].emit('unpipe', this);
+ dests[i].emit('unpipe', this, unpipeInfo);
}return this;
}
@@ -4499,7 +8445,7 @@ Readable.prototype.unpipe = function (dest) {
state.pipesCount -= 1;
if (state.pipesCount === 1) state.pipes = state.pipes[0];
- dest.emit('unpipe', this);
+ dest.emit('unpipe', this, unpipeInfo);
return this;
};
@@ -4520,7 +8466,7 @@ Readable.prototype.on = function (ev, fn) {
if (!state.reading) {
processNextTick(nReadingNextTick, this);
} else if (state.length) {
- emitReadable(this, state);
+ emitReadable(this);
}
}
}
@@ -4627,10 +8573,9 @@ Readable.prototype.wrap = function (stream) {
}
// proxy certain important events.
- var events = ['error', 'close', 'destroy', 'pause', 'resume'];
- forEach(events, function (ev) {
- stream.on(ev, self.emit.bind(self, ev));
- });
+ for (var n = 0; n < kProxyEvents.length; n++) {
+ stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));
+ }
// when we try to consume some more bytes, simply unpause the
// underlying stream.
@@ -4722,7 +8667,7 @@ function copyFromBufferString(n, list) {
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function copyFromBuffer(n, list) {
- var ret = bufferShim.allocUnsafe(n);
+ var ret = Buffer.allocUnsafe(n);
var p = list.head;
var c = 1;
p.data.copy(ret);
@@ -4782,43 +8727,95 @@ function indexOf(xs, x) {
}
return -1;
}
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(32)))
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(13), __webpack_require__(38)))
/***/ }),
-/* 409 */,
-/* 410 */,
-/* 411 */,
-/* 412 */,
-/* 413 */,
-/* 414 */,
-/* 415 */,
-/* 416 */,
-/* 417 */,
-/* 418 */,
-/* 419 */,
-/* 420 */,
-/* 421 */,
-/* 422 */,
-/* 423 */,
-/* 424 */,
-/* 425 */,
-/* 426 */,
-/* 427 */,
-/* 428 */,
-/* 429 */,
-/* 430 */,
-/* 431 */,
-/* 432 */,
-/* 433 */,
-/* 434 */,
-/* 435 */,
-/* 436 */,
-/* 437 */,
-/* 438 */,
-/* 439 */,
-/* 440 */,
-/* 441 */,
-/* 442 */
+/* 252 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(147).EventEmitter;
+
+
+/***/ }),
+/* 253 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/**/
+
+var processNextTick = __webpack_require__(101);
+/**/
+
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+ var _this = this;
+
+ var readableDestroyed = this._readableState && this._readableState.destroyed;
+ var writableDestroyed = this._writableState && this._writableState.destroyed;
+
+ if (readableDestroyed || writableDestroyed) {
+ if (cb) {
+ cb(err);
+ } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+ processNextTick(emitErrorNT, this, err);
+ }
+ return;
+ }
+
+ // we set destroyed to true before firing error callbacks in order
+ // to make it re-entrance safe in case destroy() is called within callbacks
+
+ if (this._readableState) {
+ this._readableState.destroyed = true;
+ }
+
+ // if this is a duplex stream mark the writable part as destroyed as well
+ if (this._writableState) {
+ this._writableState.destroyed = true;
+ }
+
+ this._destroy(err || null, function (err) {
+ if (!cb && err) {
+ processNextTick(emitErrorNT, _this, err);
+ if (_this._writableState) {
+ _this._writableState.errorEmitted = true;
+ }
+ } else if (cb) {
+ cb(err);
+ }
+ });
+}
+
+function undestroy() {
+ if (this._readableState) {
+ this._readableState.destroyed = false;
+ this._readableState.reading = false;
+ this._readableState.ended = false;
+ this._readableState.endEmitted = false;
+ }
+
+ if (this._writableState) {
+ this._writableState.destroyed = false;
+ this._writableState.ended = false;
+ this._writableState.ending = false;
+ this._writableState.finished = false;
+ this._writableState.errorEmitted = false;
+ }
+}
+
+function emitErrorNT(self, err) {
+ self.emit('error', err);
+}
+
+module.exports = {
+ destroy: destroy,
+ undestroy: undestroy
+};
+
+/***/ }),
+/* 254 */
/***/ (function(module, exports, __webpack_require__) {
// Copyright Joyent, Inc. and other Node contributors.
@@ -4842,7 +8839,7 @@ function indexOf(xs, x) {
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-var Buffer = __webpack_require__(56).Buffer;
+var Buffer = __webpack_require__(75).Buffer;
var isBufferEncoding = Buffer.isEncoding
|| function(encoding) {
@@ -5045,1456 +9042,439 @@ function base64DetectIncompleteChar(buffer) {
/***/ }),
-/* 443 */
+/* 255 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var router_1 = __webpack_require__(45);
-var AddOnComponent = (function () {
- function AddOnComponent(route) {
- this.route = route;
- this.name$ = route
- .params
- .select('name');
- }
- return AddOnComponent;
-}());
-AddOnComponent = __decorate([
- core_1.Component({
- selector: 'add-on',
- template: __webpack_require__(670),
- styles: [__webpack_require__(722)],
- host: {
- 'class': 'container-fluid'
- }
- }),
- __metadata("design:paramtypes", [router_1.ActivatedRoute])
-], AddOnComponent);
-exports.AddOnComponent = AddOnComponent;
-
-
-/***/ }),
-/* 444 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(443));
-__export(__webpack_require__(1011));
-
-
-/***/ }),
-/* 445 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var store_1 = __webpack_require__(9);
-var BehaviorSubject_1 = __webpack_require__(50);
-__webpack_require__(411);
-__webpack_require__(272);
-var actions_1 = __webpack_require__(54);
-var KeymapAddComponent = (function () {
- function KeymapAddComponent(store) {
- this.store = store;
- this.presetsAll$ = store.select(function (appState) { return appState.presetKeymaps; });
- this.filterExpression$ = new BehaviorSubject_1.BehaviorSubject('');
- this.presets$ = this.presetsAll$
- .combineLatest(this.filterExpression$, function (keymaps, filterExpression) {
- return keymaps.filter(function (keymap) { return keymap.name.toLocaleLowerCase().includes(filterExpression); });
- })
- .publishReplay(1)
- .refCount();
- }
- KeymapAddComponent.prototype.filterKeyboards = function (filterExpression) {
- this.filterExpression$.next(filterExpression);
- };
- KeymapAddComponent.prototype.addKeymap = function (keymap) {
- this.store.dispatch(actions_1.KeymapActions.addKeymap(keymap));
- };
- return KeymapAddComponent;
-}());
-KeymapAddComponent = __decorate([
- core_1.Component({
- selector: 'keymap-add',
- template: __webpack_require__(672),
- styles: [__webpack_require__(724)],
- host: {
- 'class': 'container-fluid'
- }
- }),
- __metadata("design:paramtypes", [store_1.Store])
-], KeymapAddComponent);
-exports.KeymapAddComponent = KeymapAddComponent;
-
-
-/***/ }),
-/* 446 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var keymap_edit_component_1 = __webpack_require__(447);
-exports.KeymapEditComponent = keymap_edit_component_1.KeymapEditComponent;
-var keymap_edit_guard_service_1 = __webpack_require__(1014);
-exports.KeymapEditGuard = keymap_edit_guard_service_1.KeymapEditGuard;
-
-
-/***/ }),
-/* 447 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var router_1 = __webpack_require__(45);
-__webpack_require__(375);
-var store_1 = __webpack_require__(9);
-__webpack_require__(412);
-__webpack_require__(123);
-__webpack_require__(65);
-__webpack_require__(272);
-__webpack_require__(273);
-var file_saver_1 = __webpack_require__(669);
-var user_configuration_1 = __webpack_require__(55);
-var KeymapEditComponent = (function () {
- function KeymapEditComponent(store, route) {
- this.store = store;
- this.route = route;
- this.keymap$ = route
- .params
- .select('abbr')
- .switchMap(function (abbr) { return store.let(user_configuration_1.getKeymap(abbr)); })
- .publishReplay(1)
- .refCount();
- this.deletable$ = store.let(user_configuration_1.getKeymaps())
- .map(function (keymaps) { return keymaps.length > 1; });
- }
- KeymapEditComponent.prototype.downloadKeymap = function () {
- var _this = this;
- var exportableJSON$ = this.keymap$
- .switchMap(function (keymap) { return _this.toExportableJSON(keymap); })
- .map(function (exportableJSON) { return JSON.stringify(exportableJSON); });
- this.keymap$
- .combineLatest(exportableJSON$)
- .first()
- .subscribe(function (latest) {
- var keymap = latest[0];
- var exportableJSON = latest[1];
- var fileName = keymap.name + '_keymap.json';
- file_saver_1.saveAs(new Blob([exportableJSON], { type: 'application/json' }), fileName);
- });
- };
- KeymapEditComponent.prototype.toExportableJSON = function (keymap) {
- return this.store
- .let(user_configuration_1.getUserConfiguration())
- .first()
- .map(function (userConfiguration) {
- return {
- site: 'https://ultimatehackingkeyboard.com',
- description: 'Ultimate Hacking Keyboard keymap',
- keyboardModel: 'UHK60',
- dataModelVersion: userConfiguration.dataModelVersion,
- objectType: 'keymap',
- objectValue: keymap.toJsonObject()
- };
- });
- };
- return KeymapEditComponent;
-}());
-KeymapEditComponent = __decorate([
- core_1.Component({
- selector: 'keymap-edit',
- template: __webpack_require__(673),
- styles: [__webpack_require__(725)],
- host: {
- 'class': 'container-fluid'
- }
- }),
- __metadata("design:paramtypes", [store_1.Store,
- router_1.ActivatedRoute])
-], KeymapEditComponent);
-exports.KeymapEditComponent = KeymapEditComponent;
-
-
-/***/ }),
-/* 448 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var router_1 = __webpack_require__(45);
-var store_1 = __webpack_require__(9);
-var actions_1 = __webpack_require__(54);
-var user_configuration_1 = __webpack_require__(55);
-var MacroEditComponent = (function () {
- function MacroEditComponent(store, route) {
- var _this = this;
- this.store = store;
- this.route = route;
- this.subscription = route
- .params
- .select('id')
- .switchMap(function (id) { return store.let(user_configuration_1.getMacro(+id)); })
- .subscribe(function (macro) {
- _this.macro = macro;
- });
- this.isNew = this.route.snapshot.params['empty'] === 'new';
- }
- MacroEditComponent.prototype.ngOnDestroy = function () {
- this.subscription.unsubscribe();
- };
- MacroEditComponent.prototype.addAction = function (macroId, action) {
- this.store.dispatch(actions_1.MacroActions.addMacroAction(macroId, action));
- };
- MacroEditComponent.prototype.editAction = function (macroId, index, action) {
- this.store.dispatch(actions_1.MacroActions.saveMacroAction(macroId, index, action));
- };
- MacroEditComponent.prototype.deleteAction = function (macroId, index, action) {
- this.store.dispatch(actions_1.MacroActions.deleteMacroAction(macroId, index, action));
- };
- MacroEditComponent.prototype.reorderAction = function (macroId, oldIndex, newIndex) {
- this.store.dispatch(actions_1.MacroActions.reorderMacroAction(macroId, oldIndex, newIndex));
- };
- return MacroEditComponent;
-}());
-MacroEditComponent = __decorate([
- core_1.Component({
- selector: 'macro-edit',
- template: __webpack_require__(681),
- styles: [__webpack_require__(732)],
- host: {
- 'class': 'container-fluid'
- }
- }),
- __metadata("design:paramtypes", [store_1.Store, router_1.ActivatedRoute])
-], MacroEditComponent);
-exports.MacroEditComponent = MacroEditComponent;
-
-
-/***/ }),
-/* 449 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(1039));
-
-
-/***/ }),
-/* 450 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(451));
-__export(__webpack_require__(1056));
-
-
-/***/ }),
-/* 451 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var SettingsComponent = (function () {
- function SettingsComponent() {
- }
- return SettingsComponent;
-}());
-SettingsComponent = __decorate([
- core_1.Component({
- selector: 'settings',
- template: __webpack_require__(696),
- styles: [__webpack_require__(747)],
- host: {
- 'class': 'container-fluid'
- }
- }),
- __metadata("design:paramtypes", [])
-], SettingsComponent);
-exports.SettingsComponent = SettingsComponent;
-
-
-/***/ }),
-/* 452 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(1088));
-__export(__webpack_require__(1089));
-
-
-/***/ }),
-/* 453 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(Buffer, process) {
-Object.defineProperty(exports, "__esModule", { value: true });
-var UhkBuffer = (function () {
- function UhkBuffer() {
- this._enableDump = false;
- this.offset = 0;
- this.bytesToBacktrack = 0;
- this.buffer = new Buffer(UhkBuffer.eepromSize);
- this.buffer.fill(0);
- }
- UhkBuffer.simpleElementWriter = function (buffer, element) {
- element.toBinary(buffer); // TODO: Remove any
- };
- UhkBuffer.prototype.readInt8 = function () {
- var value = this.buffer.readInt8(this.offset);
- this.dump("i8(" + value + ")");
- this.bytesToBacktrack = 1;
- this.offset += this.bytesToBacktrack;
- return value;
- };
- UhkBuffer.prototype.writeInt8 = function (value) {
- this.dump("i8(" + value + ")");
- this.buffer.writeInt8(value, this.offset);
- this.offset += 1;
- };
- UhkBuffer.prototype.readUInt8 = function () {
- var value = this.buffer.readUInt8(this.offset);
- this.dump("u8(" + value + ")");
- this.bytesToBacktrack = 1;
- this.offset += this.bytesToBacktrack;
- return value;
- };
- UhkBuffer.prototype.writeUInt8 = function (value) {
- this.dump("u8(" + value + ")");
- this.buffer.writeUInt8(value, this.offset);
- this.offset += 1;
- };
- UhkBuffer.prototype.readInt16 = function () {
- var value = this.buffer.readInt16LE(this.offset);
- this.dump("i16(" + value + ")");
- this.bytesToBacktrack = 2;
- this.offset += this.bytesToBacktrack;
- return value;
- };
- UhkBuffer.prototype.writeInt16 = function (value) {
- this.dump("i16(" + value + ")");
- this.buffer.writeInt16LE(value, this.offset);
- this.offset += 2;
- };
- UhkBuffer.prototype.readUInt16 = function () {
- var value = this.buffer.readUInt16LE(this.offset);
- this.dump("u16(" + value + ")");
- this.bytesToBacktrack = 2;
- this.offset += this.bytesToBacktrack;
- return value;
- };
- UhkBuffer.prototype.writeUInt16 = function (value) {
- this.dump("u16(" + value + ")");
- this.buffer.writeUInt16LE(value, this.offset);
- this.offset += 2;
- };
- UhkBuffer.prototype.readInt32 = function () {
- var value = this.buffer.readInt32LE(this.offset);
- this.dump("i32(" + value + ")");
- this.bytesToBacktrack = 4;
- this.offset += this.bytesToBacktrack;
- return value;
- };
- UhkBuffer.prototype.writeInt32 = function (value) {
- this.dump("i32(" + value + ")");
- this.buffer.writeInt32LE(value, this.offset);
- this.offset += 4;
- };
- UhkBuffer.prototype.readUInt32 = function () {
- var value = this.buffer.readUInt32LE(this.offset);
- this.dump("u32(" + value + ")");
- this.bytesToBacktrack = 4;
- this.offset += this.bytesToBacktrack;
- return value;
- };
- UhkBuffer.prototype.writeUInt32 = function (value) {
- this.dump("u32(" + value + ")");
- this.buffer.writeUInt32LE(value, this.offset);
- this.offset += 4;
- };
- UhkBuffer.prototype.readCompactLength = function () {
- var length = this.readUInt8();
- if (length === UhkBuffer.longCompactLengthPrefix) {
- length += this.readUInt8() << 8;
- }
- return length;
- };
- UhkBuffer.prototype.writeCompactLength = function (length) {
- if (length >= UhkBuffer.longCompactLengthPrefix) {
- this.writeUInt8(UhkBuffer.longCompactLengthPrefix);
- this.writeUInt16(length);
- }
- else {
- this.writeUInt8(length);
- }
- };
- UhkBuffer.prototype.readString = function () {
- var stringByteLength = this.readCompactLength();
- var str = this.buffer.toString(UhkBuffer.stringEncoding, this.offset, this.offset + stringByteLength);
- this.dump(UhkBuffer.stringEncoding + "(" + str + ")");
- this.bytesToBacktrack = stringByteLength;
- this.offset += stringByteLength;
- return str;
- };
- UhkBuffer.prototype.writeString = function (str) {
- var stringByteLength = Buffer.byteLength(str, UhkBuffer.stringEncoding);
- if (stringByteLength > UhkBuffer.maxCompactLength) {
- throw "Cannot serialize string: " + stringByteLength + " bytes is larger\n than the maximum allowed length of " + UhkBuffer.maxCompactLength + " bytes";
- }
- this.writeCompactLength(stringByteLength);
- this.dump(UhkBuffer.stringEncoding + "(" + str + ")");
- this.buffer.write(str, this.offset, stringByteLength, UhkBuffer.stringEncoding);
- this.offset += stringByteLength;
- };
- UhkBuffer.prototype.readBoolean = function () {
- return this.readUInt8() !== 0;
- };
- UhkBuffer.prototype.writeBoolean = function (bool) {
- this.writeUInt8(bool ? 1 : 0);
- };
- UhkBuffer.prototype.readArray = function (elementReader) {
- var array = [];
- var length = this.readCompactLength();
- for (var i = 0; i < length; ++i) {
- array.push(elementReader(this, i));
- }
- return array;
- };
- UhkBuffer.prototype.writeArray = function (array, elementWriter) {
- if (elementWriter === void 0) { elementWriter = UhkBuffer.simpleElementWriter; }
- var length = array.length;
- this.writeCompactLength(length);
- for (var i = 0; i < length; ++i) {
- elementWriter(this, array[i], i);
- }
- };
- UhkBuffer.prototype.backtrack = function () {
- this.offset -= this.bytesToBacktrack;
- this.bytesToBacktrack = 0;
- };
- UhkBuffer.prototype.getBufferContent = function () {
- return this.buffer.slice(0, this.offset);
- };
- Object.defineProperty(UhkBuffer.prototype, "enableDump", {
- get: function () {
- return this._enableDump;
- },
- set: function (value) {
- if (value) {
- UhkBuffer.isFirstElementToDump = true;
- }
- this._enableDump = value;
- },
- enumerable: true,
- configurable: true
- });
- UhkBuffer.prototype.dump = function (value) {
- if (!this.enableDump) {
- return;
- }
- if (!UhkBuffer.isFirstElementToDump) {
- process.stdout.write(', ');
- }
- process.stdout.write(value);
- if (UhkBuffer.isFirstElementToDump) {
- UhkBuffer.isFirstElementToDump = false;
- }
- };
- return UhkBuffer;
-}());
-UhkBuffer.eepromSize = 32 * 1024;
-UhkBuffer.maxCompactLength = 0xFFFF;
-UhkBuffer.longCompactLengthPrefix = 0xFF;
-UhkBuffer.stringEncoding = 'utf8';
-UhkBuffer.isFirstElementToDump = false;
-exports.UhkBuffer = UhkBuffer;
-
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56).Buffer, __webpack_require__(32)))
-
-/***/ }),
-/* 454 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var Module_1 = __webpack_require__(456);
-var Layer = (function () {
- function Layer(layers) {
- if (!layers) {
- return;
- }
- this.modules = layers.modules.map(function (module) { return new Module_1.Module(module); });
- }
- Layer.prototype.fromJsonObject = function (jsonObject, macros) {
- this.modules = jsonObject.modules.map(function (module) { return new Module_1.Module().fromJsonObject(module, macros); });
- return this;
- };
- Layer.prototype.fromBinary = function (buffer, macros) {
- this.modules = buffer.readArray(function (uhkBuffer) {
- return new Module_1.Module().fromBinary(uhkBuffer, macros);
- });
- return this;
- };
- Layer.prototype.toJsonObject = function (macros) {
- return {
- modules: this.modules.map(function (module) { return module.toJsonObject(macros); })
- };
- };
- Layer.prototype.toBinary = function (buffer, macros) {
- buffer.writeArray(this.modules, function (uhkBuffer, module) {
- module.toBinary(uhkBuffer, macros);
- });
- };
- Layer.prototype.toString = function () {
- return "";
- };
- Layer.prototype.renameKeymap = function (oldAbbr, newAbbr) {
- var _this = this;
- var modules;
- var moduleModified = false;
- this.modules.forEach(function (module, index) {
- var newModule = module.renameKeymap(oldAbbr, newAbbr);
- if (newModule !== module) {
- if (!moduleModified) {
- modules = _this.modules.slice();
- moduleModified = true;
- }
- modules[index] = newModule;
- }
- });
- if (moduleModified) {
- var newLayer = Object.assign(new Layer(), this);
- newLayer.modules = modules;
- return newLayer;
- }
- return this;
- };
- return Layer;
-}());
-exports.Layer = Layer;
-
-
-/***/ }),
-/* 455 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-var LongPressAction;
-(function (LongPressAction) {
- LongPressAction[LongPressAction["leftCtrl"] = 0] = "leftCtrl";
- LongPressAction[LongPressAction["leftShift"] = 1] = "leftShift";
- LongPressAction[LongPressAction["leftAlt"] = 2] = "leftAlt";
- LongPressAction[LongPressAction["leftSuper"] = 3] = "leftSuper";
- LongPressAction[LongPressAction["rightCtrl"] = 4] = "rightCtrl";
- LongPressAction[LongPressAction["rightShift"] = 5] = "rightShift";
- LongPressAction[LongPressAction["rightAlt"] = 6] = "rightAlt";
- LongPressAction[LongPressAction["rightSuper"] = 7] = "rightSuper";
- LongPressAction[LongPressAction["mod"] = 8] = "mod";
- LongPressAction[LongPressAction["fn"] = 9] = "fn";
- LongPressAction[LongPressAction["mouse"] = 10] = "mouse";
-})(LongPressAction = exports.LongPressAction || (exports.LongPressAction = {}));
-;
-
-
-/***/ }),
-/* 456 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var key_action_1 = __webpack_require__(22);
-var key_action_2 = __webpack_require__(22);
-var PointerRole;
-(function (PointerRole) {
- PointerRole[PointerRole["none"] = 0] = "none";
- PointerRole[PointerRole["move"] = 1] = "move";
- PointerRole[PointerRole["scroll"] = 2] = "scroll";
-})(PointerRole || (PointerRole = {}));
-var Module = (function () {
- function Module(other) {
- if (!other) {
- return;
- }
- this.id = other.id;
- this.keyActions = other.keyActions.map(function (keyAction) { return key_action_1.Helper.createKeyAction(keyAction); });
- this.pointerRole = other.pointerRole;
- }
- Module.prototype.fromJsonObject = function (jsonObject, macros) {
- this.id = jsonObject.id;
- this.pointerRole = PointerRole[jsonObject.pointerRole];
- this.keyActions = jsonObject.keyActions.map(function (keyAction) {
- return key_action_1.Helper.createKeyAction(keyAction, macros);
- });
- return this;
- };
- Module.prototype.fromBinary = function (buffer, macros) {
- this.id = buffer.readUInt8();
- this.pointerRole = buffer.readUInt8();
- var keyActionsLength = buffer.readCompactLength();
- this.keyActions = [];
- for (var i = 0; i < keyActionsLength; ++i) {
- this.keyActions.push(key_action_1.Helper.createKeyAction(buffer, macros));
- }
- return this;
- };
- Module.prototype.toJsonObject = function (macros) {
- return {
- id: this.id,
- pointerRole: PointerRole[this.pointerRole],
- keyActions: this.keyActions.map(function (keyAction) {
- if (keyAction && (macros || !(keyAction instanceof key_action_2.PlayMacroAction || keyAction instanceof key_action_2.SwitchLayerAction))) {
- return keyAction.toJsonObject(macros);
- }
- })
- };
- };
- Module.prototype.toBinary = function (buffer, macros) {
- buffer.writeUInt8(this.id);
- buffer.writeUInt8(this.pointerRole);
- var noneAction = new key_action_1.NoneAction();
- var keyActions = this.keyActions.map(function (keyAction) {
- if (keyAction) {
- return keyAction;
- }
- return noneAction;
- });
- buffer.writeArray(keyActions, function (uhkBuffer, keyAction) {
- keyAction.toBinary(uhkBuffer, macros);
- });
- };
- Module.prototype.toString = function () {
- return "";
- };
- Module.prototype.renameKeymap = function (oldAbbr, newAbbr) {
- var _this = this;
- var keyActions;
- var keyActionModified = false;
- this.keyActions.forEach(function (keyAction, index) {
- if (!keyAction) {
- return;
- }
- var newKeyAction = keyAction.renameKeymap(oldAbbr, newAbbr);
- if (newKeyAction !== keyAction) {
- if (!keyActionModified) {
- keyActions = _this.keyActions.slice();
- keyActionModified = true;
- }
- keyActions[index] = newKeyAction;
- }
- });
- if (keyActionModified) {
- var newModule = Object.assign(new Module(), this);
- newModule.keyActions = keyActions;
- return newModule;
- }
- return this;
- };
- return Module;
-}());
-__decorate([
- assert_1.assertUInt8,
- __metadata("design:type", Number)
-], Module.prototype, "id", void 0);
-__decorate([
- assert_1.assertEnum(PointerRole),
- __metadata("design:type", Number)
-], Module.prototype, "pointerRole", void 0);
-exports.Module = Module;
-
-
-/***/ }),
-/* 457 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __extends = (this && this.__extends) || (function () {
- var extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return function (d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
-})();
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var MacroAction_1 = __webpack_require__(68);
-var DelayMacroAction = (function (_super) {
- __extends(DelayMacroAction, _super);
- function DelayMacroAction(other) {
- var _this = _super.call(this) || this;
- if (!other) {
- return _this;
- }
- _this.delay = other.delay;
- return _this;
- }
- DelayMacroAction.prototype.fromJsonObject = function (jsObject) {
- this.assertMacroActionType(jsObject);
- this.delay = jsObject.delay;
- return this;
- };
- DelayMacroAction.prototype.fromBinary = function (buffer) {
- this.readAndAssertMacroActionId(buffer);
- this.delay = buffer.readUInt16();
- return this;
- };
- DelayMacroAction.prototype.toJsonObject = function () {
- return {
- macroActionType: MacroAction_1.macroActionType.DelayMacroAction,
- delay: this.delay
- };
- };
- DelayMacroAction.prototype.toBinary = function (buffer) {
- buffer.writeUInt8(MacroAction_1.MacroActionId.DelayMacroAction);
- buffer.writeUInt16(this.delay);
- };
- DelayMacroAction.prototype.toString = function () {
- return "";
- };
- return DelayMacroAction;
-}(MacroAction_1.MacroAction));
-__decorate([
- assert_1.assertUInt16,
- __metadata("design:type", Number)
-], DelayMacroAction.prototype, "delay", void 0);
-exports.DelayMacroAction = DelayMacroAction;
-
-
-/***/ }),
-/* 458 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __extends = (this && this.__extends) || (function () {
- var extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return function (d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
-})();
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var MacroAction_1 = __webpack_require__(68);
-var NUM_OF_COMBINATIONS = 3; // Cases: scancode, modifer, both
-var KeyMacroAction = (function (_super) {
- __extends(KeyMacroAction, _super);
- function KeyMacroAction(other) {
- var _this = _super.call(this) || this;
- if (!other) {
- return _this;
- }
- _this.action = other.action;
- _this.scancode = other.scancode;
- _this.modifierMask = other.modifierMask;
- return _this;
- }
- KeyMacroAction.prototype.fromJsonObject = function (jsObject) {
- this.assertMacroActionType(jsObject);
- this.action = MacroAction_1.MacroSubAction[jsObject.action];
- this.scancode = jsObject.scancode;
- this.modifierMask = jsObject.modifierMask;
- return this;
- };
- KeyMacroAction.prototype.fromBinary = function (buffer) {
- var macroActionId = this.readAndAssertMacroActionId(buffer);
- var keyMacroType = macroActionId - MacroAction_1.MacroActionId.KeyMacroAction;
- this.action = Math.floor(keyMacroType / NUM_OF_COMBINATIONS);
- keyMacroType %= NUM_OF_COMBINATIONS;
- if (keyMacroType % 2 === 0) {
- this.scancode = buffer.readUInt8();
- }
- if (keyMacroType !== 0) {
- this.modifierMask = buffer.readUInt8();
- }
- return this;
- };
- KeyMacroAction.prototype.toJsonObject = function () {
- var jsObject = {
- macroActionType: MacroAction_1.macroActionType.KeyMacroAction,
- action: MacroAction_1.MacroSubAction[this.action]
- };
- if (this.hasScancode()) {
- jsObject.scancode = this.scancode;
- }
- if (this.hasModifiers()) {
- jsObject.modifierMask = this.modifierMask;
- }
- return jsObject;
- };
- KeyMacroAction.prototype.toBinary = function (buffer) {
- var keyMacroType = MacroAction_1.MacroActionId.KeyMacroAction;
- keyMacroType += NUM_OF_COMBINATIONS * this.action;
- if (this.hasModifiers()) {
- ++keyMacroType;
- if (this.hasScancode()) {
- ++keyMacroType;
- }
- }
- buffer.writeUInt8(keyMacroType);
- if (this.hasScancode()) {
- buffer.writeUInt8(this.scancode);
- }
- if (this.hasModifiers()) {
- buffer.writeUInt8(this.modifierMask);
- }
- };
- KeyMacroAction.prototype.toString = function () {
- return "";
- };
- KeyMacroAction.prototype.isModifierActive = function (modifier) {
- return (this.modifierMask & modifier) > 0;
- };
- KeyMacroAction.prototype.hasScancode = function () {
- return !!this.scancode;
- };
- KeyMacroAction.prototype.hasModifiers = function () {
- return !!this.modifierMask;
- };
- KeyMacroAction.prototype.isHoldAction = function () {
- return this.action === MacroAction_1.MacroSubAction.hold;
- };
- KeyMacroAction.prototype.isPressAction = function () {
- return this.action === MacroAction_1.MacroSubAction.press;
- };
- KeyMacroAction.prototype.isReleaseAction = function () {
- return this.action === MacroAction_1.MacroSubAction.release;
- };
- return KeyMacroAction;
-}(MacroAction_1.MacroAction));
-__decorate([
- assert_1.assertEnum(MacroAction_1.MacroSubAction),
- __metadata("design:type", Number)
-], KeyMacroAction.prototype, "action", void 0);
-__decorate([
- assert_1.assertUInt8,
- __metadata("design:type", Number)
-], KeyMacroAction.prototype, "scancode", void 0);
-__decorate([
- assert_1.assertUInt8,
- __metadata("design:type", Number)
-], KeyMacroAction.prototype, "modifierMask", void 0);
-exports.KeyMacroAction = KeyMacroAction;
-
-
-/***/ }),
-/* 459 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __extends = (this && this.__extends) || (function () {
- var extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return function (d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
-})();
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var MacroAction_1 = __webpack_require__(68);
-var MouseButtons;
-(function (MouseButtons) {
- MouseButtons[MouseButtons["Left"] = 1] = "Left";
- MouseButtons[MouseButtons["Middle"] = 2] = "Middle";
- MouseButtons[MouseButtons["Right"] = 4] = "Right";
-})(MouseButtons = exports.MouseButtons || (exports.MouseButtons = {}));
-;
-var MouseButtonMacroAction = (function (_super) {
- __extends(MouseButtonMacroAction, _super);
- function MouseButtonMacroAction(other) {
- var _this = _super.call(this) || this;
- if (!other) {
- return _this;
- }
- _this.action = other.action;
- _this.mouseButtonsMask = other.mouseButtonsMask;
- return _this;
- }
- MouseButtonMacroAction.prototype.fromJsonObject = function (jsObject) {
- this.assertMacroActionType(jsObject);
- this.action = MacroAction_1.MacroSubAction[jsObject.action];
- this.mouseButtonsMask = jsObject.mouseButtonsMask;
- return this;
- };
- MouseButtonMacroAction.prototype.fromBinary = function (buffer) {
- var macroActionId = this.readAndAssertMacroActionId(buffer);
- this.action = macroActionId - MacroAction_1.MacroActionId.MouseButtonMacroAction;
- this.mouseButtonsMask = buffer.readUInt8();
- return this;
- };
- MouseButtonMacroAction.prototype.toJsonObject = function () {
- return {
- macroActionType: MacroAction_1.macroActionType.MouseButtonMacroAction,
- action: MacroAction_1.MacroSubAction[this.action],
- mouseButtonsMask: this.mouseButtonsMask
- };
- };
- MouseButtonMacroAction.prototype.toBinary = function (buffer) {
- buffer.writeUInt8(MacroAction_1.MacroActionId.MouseButtonMacroAction + this.action);
- buffer.writeUInt8(this.mouseButtonsMask);
- };
- MouseButtonMacroAction.prototype.setMouseButtons = function (buttonStates) {
- var bitmask = 0;
- for (var i = 0; i < buttonStates.length; i++) {
- bitmask |= Number(buttonStates[i]) << i;
- }
- this.mouseButtonsMask = bitmask;
- };
- MouseButtonMacroAction.prototype.getMouseButtons = function () {
- var enabledMouseButtons = [];
- for (var bitmask = this.mouseButtonsMask; bitmask; bitmask >>>= 1) {
- enabledMouseButtons.push(Boolean(bitmask & 1));
- }
- return enabledMouseButtons;
- };
- MouseButtonMacroAction.prototype.toString = function () {
- return "";
- };
- MouseButtonMacroAction.prototype.hasButtons = function () {
- return this.mouseButtonsMask !== 0;
- };
- MouseButtonMacroAction.prototype.isOnlyHoldAction = function () {
- return this.action === MacroAction_1.MacroSubAction.hold;
- };
- MouseButtonMacroAction.prototype.isOnlyPressAction = function () {
- return this.action === MacroAction_1.MacroSubAction.press;
- };
- MouseButtonMacroAction.prototype.isOnlyReleaseAction = function () {
- return this.action === MacroAction_1.MacroSubAction.release;
- };
- return MouseButtonMacroAction;
-}(MacroAction_1.MacroAction));
-__decorate([
- assert_1.assertEnum(MacroAction_1.MacroSubAction),
- __metadata("design:type", Number)
-], MouseButtonMacroAction.prototype, "action", void 0);
-__decorate([
- assert_1.assertUInt8,
- __metadata("design:type", Number)
-], MouseButtonMacroAction.prototype, "mouseButtonsMask", void 0);
-exports.MouseButtonMacroAction = MouseButtonMacroAction;
-
-
-/***/ }),
-/* 460 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __extends = (this && this.__extends) || (function () {
- var extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return function (d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
-})();
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var MacroAction_1 = __webpack_require__(68);
-var MoveMouseMacroAction = (function (_super) {
- __extends(MoveMouseMacroAction, _super);
- function MoveMouseMacroAction(other) {
- var _this = _super.call(this) || this;
- if (!other) {
- return _this;
- }
- _this.x = other.x;
- _this.y = other.y;
- return _this;
- }
- MoveMouseMacroAction.prototype.fromJsonObject = function (jsObject) {
- this.assertMacroActionType(jsObject);
- this.x = jsObject.x;
- this.y = jsObject.y;
- return this;
- };
- MoveMouseMacroAction.prototype.fromBinary = function (buffer) {
- this.readAndAssertMacroActionId(buffer);
- this.x = buffer.readInt16();
- this.y = buffer.readInt16();
- return this;
- };
- MoveMouseMacroAction.prototype.toJsonObject = function () {
- return {
- macroActionType: MacroAction_1.macroActionType.MoveMouseMacroAction,
- x: this.x,
- y: this.y
- };
- };
- MoveMouseMacroAction.prototype.toBinary = function (buffer) {
- buffer.writeUInt8(MacroAction_1.MacroActionId.MoveMouseMacroAction);
- buffer.writeInt16(this.x);
- buffer.writeInt16(this.y);
- };
- MoveMouseMacroAction.prototype.toString = function () {
- return "";
- };
- return MoveMouseMacroAction;
-}(MacroAction_1.MacroAction));
-__decorate([
- assert_1.assertInt16,
- __metadata("design:type", Number)
-], MoveMouseMacroAction.prototype, "x", void 0);
-__decorate([
- assert_1.assertInt16,
- __metadata("design:type", Number)
-], MoveMouseMacroAction.prototype, "y", void 0);
-exports.MoveMouseMacroAction = MoveMouseMacroAction;
-
-
-/***/ }),
-/* 461 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __extends = (this && this.__extends) || (function () {
- var extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return function (d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
-})();
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __webpack_require__(26);
-var MacroAction_1 = __webpack_require__(68);
-var ScrollMouseMacroAction = (function (_super) {
- __extends(ScrollMouseMacroAction, _super);
- function ScrollMouseMacroAction(other) {
- var _this = _super.call(this) || this;
- if (!other) {
- return _this;
- }
- _this.x = other.x;
- _this.y = other.y;
- return _this;
- }
- ScrollMouseMacroAction.prototype.fromJsonObject = function (jsObject) {
- this.assertMacroActionType(jsObject);
- this.x = jsObject.x;
- this.y = jsObject.y;
- return this;
- };
- ScrollMouseMacroAction.prototype.fromBinary = function (buffer) {
- this.readAndAssertMacroActionId(buffer);
- this.x = buffer.readInt16();
- this.y = buffer.readInt16();
- return this;
- };
- ScrollMouseMacroAction.prototype.toJsonObject = function () {
- return {
- macroActionType: MacroAction_1.macroActionType.ScrollMouseMacroAction,
- x: this.x,
- y: this.y
- };
- };
- ScrollMouseMacroAction.prototype.toBinary = function (buffer) {
- buffer.writeUInt8(MacroAction_1.MacroActionId.ScrollMouseMacroAction);
- buffer.writeInt16(this.x);
- buffer.writeInt16(this.y);
- };
- ScrollMouseMacroAction.prototype.toString = function () {
- return "";
- };
- return ScrollMouseMacroAction;
-}(MacroAction_1.MacroAction));
-__decorate([
- assert_1.assertInt16,
- __metadata("design:type", Number)
-], ScrollMouseMacroAction.prototype, "x", void 0);
-__decorate([
- assert_1.assertInt16,
- __metadata("design:type", Number)
-], ScrollMouseMacroAction.prototype, "y", void 0);
-exports.ScrollMouseMacroAction = ScrollMouseMacroAction;
-
-
-/***/ }),
-/* 462 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __extends = (this && this.__extends) || (function () {
- var extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return function (d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
- };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-var MacroAction_1 = __webpack_require__(68);
-var TextMacroAction = (function (_super) {
- __extends(TextMacroAction, _super);
- function TextMacroAction(other) {
- var _this = _super.call(this) || this;
- if (!other) {
- return _this;
- }
- _this.text = other.text;
- return _this;
- }
- TextMacroAction.prototype.fromJsonObject = function (jsObject) {
- this.assertMacroActionType(jsObject);
- this.text = jsObject.text;
- return this;
- };
- TextMacroAction.prototype.fromBinary = function (buffer) {
- this.readAndAssertMacroActionId(buffer);
- this.text = buffer.readString();
- return this;
- };
- TextMacroAction.prototype.toJsonObject = function () {
- return {
- macroActionType: MacroAction_1.macroActionType.TextMacroAction,
- text: this.text
- };
- };
- TextMacroAction.prototype.toBinary = function (buffer) {
- buffer.writeUInt8(MacroAction_1.MacroActionId.TextMacroAction);
- buffer.writeString(this.text);
- };
- TextMacroAction.prototype.toString = function () {
- return "";
- };
- return TextMacroAction;
-}(MacroAction_1.MacroAction));
-exports.TextMacroAction = TextMacroAction;
-
-
-/***/ }),
-/* 463 */,
-/* 464 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/* WEBPACK VAR INJECTION */(function(process) {var WritableStream = __webpack_require__(191).Writable
-var inherits = __webpack_require__(1124).inherits
-
-module.exports = BrowserStdout
-
-
-inherits(BrowserStdout, WritableStream)
-
-function BrowserStdout(opts) {
- if (!(this instanceof BrowserStdout)) return new BrowserStdout(opts)
-
- opts = opts || {}
- WritableStream.call(this, opts)
- this.label = (opts.label !== undefined) ? opts.label : 'stdout'
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+
+
+module.exports = Transform;
+
+var Duplex = __webpack_require__(50);
+
+/**/
+var util = __webpack_require__(76);
+util.inherits = __webpack_require__(58);
+/**/
+
+util.inherits(Transform, Duplex);
+
+function TransformState(stream) {
+ this.afterTransform = function (er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+ this.writeencoding = null;
}
-BrowserStdout.prototype._write = function(chunks, encoding, cb) {
- var output = chunks.toString ? chunks.toString() : chunks
- if (this.label === false) {
- console.log(output)
- } else {
- console.log(this.label+':', output)
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb) {
+ return stream.emit('error', new Error('write callback called multiple times'));
+ }
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined) stream.push(data);
+
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
}
- process.nextTick(cb)
}
-/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(32)))
+function Transform(options) {
+ if (!(this instanceof Transform)) return new Transform(options);
+
+ Duplex.call(this, options);
+
+ this._transformState = new TransformState(this);
+
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ if (options) {
+ if (typeof options.transform === 'function') this._transform = options.transform;
+
+ if (typeof options.flush === 'function') this._flush = options.flush;
+ }
+
+ // When the writable side finishes, then flush out anything remaining.
+ this.once('prefinish', function () {
+ if (typeof this._flush === 'function') this._flush(function (er, data) {
+ done(stream, er, data);
+ });else done(stream);
+ });
+}
+
+Transform.prototype.push = function (chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+ throw new Error('_transform() is not implemented');
+};
+
+Transform.prototype._write = function (chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+Transform.prototype._destroy = function (err, cb) {
+ var _this = this;
+
+ Duplex.prototype._destroy.call(this, err, function (err2) {
+ cb(err2);
+ _this.emit('close');
+ });
+};
+
+function done(stream, er, data) {
+ if (er) return stream.emit('error', er);
+
+ if (data !== null && data !== undefined) stream.push(data);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var ts = stream._transformState;
+
+ if (ws.length) throw new Error('Calling transform done when ws.length != 0');
+
+ if (ts.transforming) throw new Error('Calling transform done when still transforming');
+
+ return stream.push(null);
+}
/***/ }),
+/* 256 */,
+/* 257 */,
+/* 258 */,
+/* 259 */,
+/* 260 */,
+/* 261 */,
+/* 262 */,
+/* 263 */,
+/* 264 */,
+/* 265 */,
+/* 266 */,
+/* 267 */,
+/* 268 */,
+/* 269 */,
+/* 270 */,
+/* 271 */,
+/* 272 */,
+/* 273 */,
+/* 274 */,
+/* 275 */,
+/* 276 */,
+/* 277 */,
+/* 278 */,
+/* 279 */,
+/* 280 */,
+/* 281 */,
+/* 282 */,
+/* 283 */,
+/* 284 */,
+/* 285 */,
+/* 286 */,
+/* 287 */,
+/* 288 */,
+/* 289 */,
+/* 290 */,
+/* 291 */,
+/* 292 */,
+/* 293 */,
+/* 294 */,
+/* 295 */,
+/* 296 */,
+/* 297 */,
+/* 298 */,
+/* 299 */,
+/* 300 */,
+/* 301 */,
+/* 302 */,
+/* 303 */,
+/* 304 */,
+/* 305 */,
+/* 306 */,
+/* 307 */,
+/* 308 */,
+/* 309 */,
+/* 310 */,
+/* 311 */,
+/* 312 */,
+/* 313 */,
+/* 314 */,
+/* 315 */,
+/* 316 */,
+/* 317 */,
+/* 318 */,
+/* 319 */,
+/* 320 */,
+/* 321 */,
+/* 322 */,
+/* 323 */,
+/* 324 */,
+/* 325 */,
+/* 326 */,
+/* 327 */,
+/* 328 */,
+/* 329 */,
+/* 330 */,
+/* 331 */,
+/* 332 */,
+/* 333 */,
+/* 334 */,
+/* 335 */,
+/* 336 */,
+/* 337 */,
+/* 338 */,
+/* 339 */,
+/* 340 */,
+/* 341 */,
+/* 342 */,
+/* 343 */,
+/* 344 */,
+/* 345 */,
+/* 346 */,
+/* 347 */,
+/* 348 */,
+/* 349 */,
+/* 350 */,
+/* 351 */,
+/* 352 */,
+/* 353 */,
+/* 354 */,
+/* 355 */,
+/* 356 */,
+/* 357 */,
+/* 358 */,
+/* 359 */,
+/* 360 */,
+/* 361 */,
+/* 362 */,
+/* 363 */,
+/* 364 */,
+/* 365 */,
+/* 366 */,
+/* 367 */,
+/* 368 */,
+/* 369 */,
+/* 370 */,
+/* 371 */,
+/* 372 */,
+/* 373 */,
+/* 374 */,
+/* 375 */,
+/* 376 */,
+/* 377 */,
+/* 378 */,
+/* 379 */,
+/* 380 */,
+/* 381 */,
+/* 382 */,
+/* 383 */,
+/* 384 */,
+/* 385 */,
+/* 386 */,
+/* 387 */,
+/* 388 */,
+/* 389 */,
+/* 390 */,
+/* 391 */,
+/* 392 */,
+/* 393 */,
+/* 394 */,
+/* 395 */,
+/* 396 */,
+/* 397 */,
+/* 398 */,
+/* 399 */,
+/* 400 */,
+/* 401 */,
+/* 402 */,
+/* 403 */,
+/* 404 */,
+/* 405 */,
+/* 406 */,
+/* 407 */,
+/* 408 */,
+/* 409 */,
+/* 410 */,
+/* 411 */,
+/* 412 */,
+/* 413 */,
+/* 414 */,
+/* 415 */,
+/* 416 */,
+/* 417 */,
+/* 418 */,
+/* 419 */,
+/* 420 */,
+/* 421 */,
+/* 422 */,
+/* 423 */,
+/* 424 */,
+/* 425 */,
+/* 426 */,
+/* 427 */,
+/* 428 */,
+/* 429 */,
+/* 430 */,
+/* 431 */,
+/* 432 */,
+/* 433 */,
+/* 434 */,
+/* 435 */,
+/* 436 */,
+/* 437 */,
+/* 438 */,
+/* 439 */,
+/* 440 */,
+/* 441 */,
+/* 442 */,
+/* 443 */,
+/* 444 */,
+/* 445 */,
+/* 446 */,
+/* 447 */,
+/* 448 */,
+/* 449 */,
+/* 450 */,
+/* 451 */,
+/* 452 */,
+/* 453 */,
+/* 454 */,
+/* 455 */,
+/* 456 */,
+/* 457 */,
+/* 458 */,
+/* 459 */,
+/* 460 */,
+/* 461 */,
+/* 462 */,
+/* 463 */,
+/* 464 */,
/* 465 */,
/* 466 */,
/* 467 */,
-/* 468 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = __webpack_require__(0);
-var forms_1 = __webpack_require__(352);
-var platform_browser_1 = __webpack_require__(162);
-var effects_1 = __webpack_require__(165);
-var store_1 = __webpack_require__(9);
-var store_devtools_1 = __webpack_require__(247);
-var store_log_monitor_1 = __webpack_require__(589);
-var ng2_dragula_1 = __webpack_require__(404);
-var ng2_select2_1 = __webpack_require__(406);
-var add_on_1 = __webpack_require__(444);
-var slider_1 = __webpack_require__(1012);
-var keymap_1 = __webpack_require__(1016);
-var layers_1 = __webpack_require__(1017);
-var macro_1 = __webpack_require__(288);
-var notification_1 = __webpack_require__(1037);
-var popover_1 = __webpack_require__(449);
-var tab_1 = __webpack_require__(193);
-var capture_keystroke_1 = __webpack_require__(1053);
-var icon_1 = __webpack_require__(1055);
-var settings_1 = __webpack_require__(450);
-var side_menu_1 = __webpack_require__(1057);
-var keyboard_1 = __webpack_require__(1059);
-var keys_1 = __webpack_require__(1061);
-var module_1 = __webpack_require__(452);
-var wrap_1 = __webpack_require__(1090);
-var main_app_1 = __webpack_require__(1118);
-var directives_1 = __webpack_require__(1104);
-var capture_service_1 = __webpack_require__(292);
-var mapper_service_1 = __webpack_require__(31);
-var effects_2 = __webpack_require__(1107);
-var reducers_1 = __webpack_require__(1110);
-var storage_1 = __webpack_require__(1113);
-var edit_1 = __webpack_require__(446);
-var not_found_1 = __webpack_require__(289);
-// Create DataStorage dependency injection
-var storageProvider = core_1.ReflectiveInjector.resolve([storage_1.DataStorage]);
-var storageInjector = core_1.ReflectiveInjector.fromResolvedProviders(storageProvider);
-var storageService = storageInjector.get(storage_1.DataStorage);
-// All reducers that are used in application
-var storeConfig = {
- userConfiguration: storageService.saveState(reducers_1.userConfigurationReducer),
- presetKeymaps: reducers_1.presetReducer
-};
-var AppModule = (function () {
- function AppModule() {
- }
- return AppModule;
-}());
-AppModule = __decorate([
- core_1.NgModule({
- declarations: [
- main_app_1.MainAppComponent,
- keymap_1.KeymapEditComponent,
- keymap_1.KeymapHeaderComponent,
- notification_1.NotificationComponent,
- keys_1.SvgIconTextKeyComponent,
- keys_1.SvgKeyboardKeyComponent,
- keys_1.SvgKeystrokeKeyComponent,
- keys_1.SvgMouseKeyComponent,
- keys_1.SvgMouseClickKeyComponent,
- keys_1.SvgMouseMoveKeyComponent,
- keys_1.SvgMouseScrollKeyComponent,
- keys_1.SvgMouseSpeedKeyComponent,
- keys_1.SvgOneLineTextKeyComponent,
- keys_1.SvgSingleIconKeyComponent,
- keys_1.SvgSwitchKeymapKeyComponent,
- keys_1.SvgTextIconKeyComponent,
- keys_1.SvgTwoLineTextKeyComponent,
- keys_1.SvgKeyboardKeyComponent,
- wrap_1.SvgKeyboardWrapComponent,
- keyboard_1.SvgKeyboardComponent,
- module_1.SvgModuleComponent,
- layers_1.LayersComponent,
- popover_1.PopoverComponent,
- keymap_1.KeymapAddComponent,
- side_menu_1.SideMenuComponent,
- tab_1.KeypressTabComponent,
- tab_1.KeymapTabComponent,
- tab_1.LayerTabComponent,
- tab_1.MacroTabComponent,
- tab_1.MouseTabComponent,
- tab_1.NoneTabComponent,
- capture_keystroke_1.CaptureKeystrokeButtonComponent,
- icon_1.IconComponent,
- macro_1.MacroEditComponent,
- macro_1.MacroListComponent,
- macro_1.MacroHeaderComponent,
- macro_1.MacroItemComponent,
- macro_1.MacroActionEditorComponent,
- macro_1.MacroDelayTabComponent,
- macro_1.MacroKeyTabComponent,
- macro_1.MacroMouseTabComponent,
- macro_1.MacroTextTabComponent,
- macro_1.MacroNotFoundComponent,
- add_on_1.AddOnComponent,
- settings_1.SettingsComponent,
- slider_1.KeyboardSliderComponent,
- directives_1.CancelableDirective
- ],
- imports: [
- platform_browser_1.BrowserModule,
- forms_1.FormsModule,
- ng2_dragula_1.DragulaModule,
- main_app_1.routing,
- store_1.StoreModule.provideStore(storeConfig, storageService.initialState()),
- store_devtools_1.StoreDevtoolsModule.instrumentStore({
- monitor: store_log_monitor_1.useLogMonitor({
- visible: false,
- position: 'right'
- })
- }),
- store_log_monitor_1.StoreLogMonitorModule,
- ng2_select2_1.Select2Module,
- effects_1.EffectsModule.runAfterBootstrap(effects_2.KeymapEffects),
- effects_1.EffectsModule.runAfterBootstrap(effects_2.MacroEffects)
- ],
- providers: [
- mapper_service_1.MapperService,
- main_app_1.appRoutingProviders,
- edit_1.KeymapEditGuard,
- not_found_1.MacroNotFoundGuard,
- capture_service_1.CaptureService
- ],
- bootstrap: [main_app_1.MainAppComponent]
- })
-], AppModule);
-exports.AppModule = AppModule;
-
-
-/***/ }),
+/* 468 */,
/* 469 */,
/* 470 */,
/* 471 */,
@@ -6605,28 +9585,7 @@ exports.AppModule = AppModule;
/* 576 */,
/* 577 */,
/* 578 */,
-/* 579 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-exports.compose = function () {
- var functions = [];
- for (var _i = 0; _i < arguments.length; _i++) {
- functions[_i - 0] = arguments[_i];
- }
- return function (arg) {
- if (functions.length === 0) {
- return arg;
- }
- var last = functions[functions.length - 1];
- var rest = functions.slice(0, -1);
- return rest.reduceRight(function (composed, fn) { return fn(composed); }, last(arg));
- };
-};
-
-
-/***/ }),
+/* 579 */,
/* 580 */,
/* 581 */,
/* 582 */,
@@ -6634,15 +9593,5850 @@ exports.compose = function () {
/* 584 */,
/* 585 */,
/* 586 */,
-/* 587 */
+/* 587 */,
+/* 588 */,
+/* 589 */,
+/* 590 */,
+/* 591 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {
+Object.defineProperty(exports, "__esModule", { value: true });
+var platform_browser_dynamic_1 = __webpack_require__(170);
+var app_module_1 = __webpack_require__(592);
+if (!process.stdout) {
+ process.stdout = __webpack_require__(832)();
+}
+platform_browser_dynamic_1.platformBrowserDynamic().bootstrapModule(app_module_1.AppModule);
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(38)))
+
+/***/ }),
+/* 592 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var forms_1 = __webpack_require__(171);
+var platform_browser_1 = __webpack_require__(42);
+var animations_1 = __webpack_require__(593);
+var angular_notifier_1 = __webpack_require__(221);
+var effects_1 = __webpack_require__(46);
+var store_1 = __webpack_require__(5);
+var store_devtools_1 = __webpack_require__(130);
+var store_log_monitor_1 = __webpack_require__(597);
+var router_store_1 = __webpack_require__(227);
+var ng2_dragula_1 = __webpack_require__(228);
+var ng2_select2_1 = __webpack_require__(215);
+var add_on_1 = __webpack_require__(229);
+var slider_1 = __webpack_require__(618);
+var keymap_1 = __webpack_require__(622);
+var layers_1 = __webpack_require__(649);
+var macro_1 = __webpack_require__(138);
+var notification_1 = __webpack_require__(715);
+var popover_1 = __webpack_require__(242);
+var tab_1 = __webpack_require__(100);
+var capture_keystroke_1 = __webpack_require__(722);
+var icon_1 = __webpack_require__(726);
+var settings_1 = __webpack_require__(243);
+var side_menu_1 = __webpack_require__(735);
+var keyboard_1 = __webpack_require__(739);
+var keys_1 = __webpack_require__(751);
+var module_1 = __webpack_require__(246);
+var wrap_1 = __webpack_require__(793);
+var main_app_1 = __webpack_require__(797);
+var directives_1 = __webpack_require__(806);
+var pipes_1 = __webpack_require__(811);
+var capture_service_1 = __webpack_require__(142);
+var mapper_service_1 = __webpack_require__(22);
+var svg_module_provider_service_1 = __webpack_require__(245);
+var effects_2 = __webpack_require__(813);
+var edit_1 = __webpack_require__(247);
+var not_found_1 = __webpack_require__(139);
+var datastorage_repository_service_1 = __webpack_require__(146);
+var local_datastorage_repository_service_1 = __webpack_require__(825);
+var default_user_configuration_service_1 = __webpack_require__(248);
+var index_1 = __webpack_require__(826);
+var logger_service_1 = __webpack_require__(828);
+var auto_update_settings_1 = __webpack_require__(829);
+var angular_notifier_config_1 = __webpack_require__(831);
+var AppModule = (function () {
+ function AppModule() {
+ }
+ return AppModule;
+}());
+AppModule = __decorate([
+ core_1.NgModule({
+ declarations: [
+ main_app_1.MainAppComponent,
+ keymap_1.KeymapEditComponent,
+ keymap_1.KeymapHeaderComponent,
+ notification_1.NotificationComponent,
+ keys_1.SvgIconTextKeyComponent,
+ keys_1.SvgKeyboardKeyComponent,
+ keys_1.SvgKeystrokeKeyComponent,
+ keys_1.SvgMouseKeyComponent,
+ keys_1.SvgMouseClickKeyComponent,
+ keys_1.SvgMouseMoveKeyComponent,
+ keys_1.SvgMouseScrollKeyComponent,
+ keys_1.SvgMouseSpeedKeyComponent,
+ keys_1.SvgOneLineTextKeyComponent,
+ keys_1.SvgSingleIconKeyComponent,
+ keys_1.SvgSwitchKeymapKeyComponent,
+ keys_1.SvgTextIconKeyComponent,
+ keys_1.SvgTwoLineTextKeyComponent,
+ keys_1.SvgKeyboardKeyComponent,
+ wrap_1.SvgKeyboardWrapComponent,
+ keyboard_1.SvgKeyboardComponent,
+ module_1.SvgModuleComponent,
+ layers_1.LayersComponent,
+ popover_1.PopoverComponent,
+ keymap_1.KeymapAddComponent,
+ side_menu_1.SideMenuComponent,
+ tab_1.KeypressTabComponent,
+ tab_1.KeymapTabComponent,
+ tab_1.LayerTabComponent,
+ tab_1.MacroTabComponent,
+ tab_1.MouseTabComponent,
+ tab_1.NoneTabComponent,
+ capture_keystroke_1.CaptureKeystrokeButtonComponent,
+ icon_1.IconComponent,
+ macro_1.MacroEditComponent,
+ macro_1.MacroListComponent,
+ macro_1.MacroHeaderComponent,
+ macro_1.MacroItemComponent,
+ macro_1.MacroActionEditorComponent,
+ macro_1.MacroDelayTabComponent,
+ macro_1.MacroKeyTabComponent,
+ macro_1.MacroMouseTabComponent,
+ macro_1.MacroTextTabComponent,
+ macro_1.MacroNotFoundComponent,
+ add_on_1.AddOnComponent,
+ settings_1.SettingsComponent,
+ slider_1.KeyboardSliderComponent,
+ directives_1.CancelableDirective,
+ directives_1.TooltipDirective,
+ pipes_1.SafeStylePipe,
+ auto_update_settings_1.AutoUpdateSettings
+ ],
+ imports: [
+ platform_browser_1.BrowserModule,
+ animations_1.BrowserAnimationsModule,
+ forms_1.FormsModule,
+ ng2_dragula_1.DragulaModule,
+ main_app_1.routing,
+ store_1.StoreModule.provideStore(index_1.reducer),
+ router_store_1.RouterStoreModule.connectRouter(),
+ store_devtools_1.StoreDevtoolsModule.instrumentStore({
+ monitor: store_log_monitor_1.useLogMonitor({
+ visible: false,
+ position: 'right'
+ })
+ }),
+ store_log_monitor_1.StoreLogMonitorModule,
+ ng2_select2_1.Select2Module,
+ angular_notifier_1.NotifierModule.withConfig(angular_notifier_config_1.angularNotifierConfig),
+ effects_1.EffectsModule.runAfterBootstrap(effects_2.KeymapEffects),
+ effects_1.EffectsModule.runAfterBootstrap(effects_2.MacroEffects),
+ effects_1.EffectsModule.runAfterBootstrap(effects_2.UserConfigEffects),
+ effects_1.EffectsModule.runAfterBootstrap(effects_2.AutoUpdateSettingsEffects),
+ effects_1.EffectsModule.runAfterBootstrap(effects_2.ApplicationEffects)
+ ],
+ providers: [
+ svg_module_provider_service_1.SvgModuleProviderService,
+ mapper_service_1.MapperService,
+ main_app_1.appRoutingProviders,
+ edit_1.KeymapEditGuard,
+ not_found_1.MacroNotFoundGuard,
+ capture_service_1.CaptureService,
+ { provide: datastorage_repository_service_1.DATA_STORAGE_REPOSITORY, useClass: local_datastorage_repository_service_1.LocalDataStorageRepositoryService },
+ default_user_configuration_service_1.DefaultUserConfigurationService,
+ logger_service_1.LogService,
+ default_user_configuration_service_1.DefaultUserConfigurationService
+ ],
+ bootstrap: [main_app_1.MainAppComponent]
+ })
+], AppModule);
+exports.AppModule = AppModule;
+
+
+/***/ }),
+/* 593 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BrowserAnimationsModule", function() { return BrowserAnimationsModule; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NoopAnimationsModule", function() { return NoopAnimationsModule; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵBrowserAnimationBuilder", function() { return BrowserAnimationBuilder; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵBrowserAnimationFactory", function() { return BrowserAnimationFactory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵAnimationRenderer", function() { return AnimationRenderer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵAnimationRendererFactory", function() { return AnimationRendererFactory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵa", function() { return BaseAnimationRenderer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵf", function() { return BROWSER_ANIMATIONS_PROVIDERS; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵg", function() { return BROWSER_NOOP_ANIMATIONS_PROVIDERS; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵb", function() { return InjectableAnimationEngine; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵd", function() { return instantiateDefaultStyleNormalizer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵe", function() { return instantiateRendererFactory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ɵc", function() { return instantiateSupportedAnimationDriver; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(29);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__angular_platform_browser__ = __webpack_require__(42);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__angular_animations__ = __webpack_require__(33);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__ = __webpack_require__(594);
+
+/**
+ * @license Angular v4.2.6
+ * (c) 2010-2017 Google, Inc. https://angular.io/
+ * License: MIT
+ */
+
+
+
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var BrowserAnimationBuilder = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](BrowserAnimationBuilder, _super);
+ /**
+ * @param {?} rootRenderer
+ */
+ function BrowserAnimationBuilder(rootRenderer) {
+ var _this = _super.call(this) || this;
+ _this._nextAnimationId = 0;
+ var typeData = {
+ id: '0',
+ encapsulation: __WEBPACK_IMPORTED_MODULE_1__angular_core__["ViewEncapsulation"].None,
+ styles: [],
+ data: { animation: [] }
+ };
+ _this._renderer = rootRenderer.createRenderer(document.body, typeData);
+ return _this;
+ }
+ /**
+ * @param {?} animation
+ * @return {?}
+ */
+ BrowserAnimationBuilder.prototype.build = function (animation) {
+ var /** @type {?} */ id = this._nextAnimationId.toString();
+ this._nextAnimationId++;
+ var /** @type {?} */ entry = Array.isArray(animation) ? __WEBPACK_IMPORTED_MODULE_3__angular_animations__["sequence"](animation) : animation;
+ issueAnimationCommand(this._renderer, null, id, 'register', [entry]);
+ return new BrowserAnimationFactory(id, this._renderer);
+ };
+ return BrowserAnimationBuilder;
+}(__WEBPACK_IMPORTED_MODULE_3__angular_animations__["AnimationBuilder"]));
+BrowserAnimationBuilder.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+BrowserAnimationBuilder.ctorParameters = function () { return [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["RendererFactory2"], },
+]; };
+var BrowserAnimationFactory = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](BrowserAnimationFactory, _super);
+ /**
+ * @param {?} _id
+ * @param {?} _renderer
+ */
+ function BrowserAnimationFactory(_id, _renderer) {
+ var _this = _super.call(this) || this;
+ _this._id = _id;
+ _this._renderer = _renderer;
+ return _this;
+ }
+ /**
+ * @param {?} element
+ * @param {?=} options
+ * @return {?}
+ */
+ BrowserAnimationFactory.prototype.create = function (element, options) {
+ return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);
+ };
+ return BrowserAnimationFactory;
+}(__WEBPACK_IMPORTED_MODULE_3__angular_animations__["AnimationFactory"]));
+var RendererAnimationPlayer = (function () {
+ /**
+ * @param {?} id
+ * @param {?} element
+ * @param {?} options
+ * @param {?} _renderer
+ */
+ function RendererAnimationPlayer(id, element, options, _renderer) {
+ this.id = id;
+ this.element = element;
+ this._renderer = _renderer;
+ this.parentPlayer = null;
+ this._started = false;
+ this.totalTime = 0;
+ this._command('create', options);
+ }
+ /**
+ * @param {?} eventName
+ * @param {?} callback
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype._listen = function (eventName, callback) {
+ return this._renderer.listen(this.element, "@@" + this.id + ":" + eventName, callback);
+ };
+ /**
+ * @param {?} command
+ * @param {...?} args
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype._command = function (command) {
+ var args = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ args[_i - 1] = arguments[_i];
+ }
+ return issueAnimationCommand(this._renderer, this.element, this.id, command, args);
+ };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.onDone = function (fn) { this._listen('done', fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.onStart = function (fn) { this._listen('start', fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.onDestroy = function (fn) { this._listen('destroy', fn); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.init = function () { this._command('init'); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.hasStarted = function () { return this._started; };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.play = function () {
+ this._command('play');
+ this._started = true;
+ };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.pause = function () { this._command('pause'); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.restart = function () { this._command('restart'); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.finish = function () { this._command('finish'); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.destroy = function () { this._command('destroy'); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.reset = function () { this._command('reset'); };
+ /**
+ * @param {?} p
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.setPosition = function (p) { this._command('setPosition', p); };
+ /**
+ * @return {?}
+ */
+ RendererAnimationPlayer.prototype.getPosition = function () { return 0; };
+ return RendererAnimationPlayer;
+}());
+/**
+ * @param {?} renderer
+ * @param {?} element
+ * @param {?} id
+ * @param {?} command
+ * @param {?} args
+ * @return {?}
+ */
+function issueAnimationCommand(renderer, element, id, command, args) {
+ return renderer.setProperty(element, "@@" + id + ":" + command, args);
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var AnimationRendererFactory = (function () {
+ /**
+ * @param {?} delegate
+ * @param {?} engine
+ * @param {?} _zone
+ */
+ function AnimationRendererFactory(delegate, engine, _zone) {
+ this.delegate = delegate;
+ this.engine = engine;
+ this._zone = _zone;
+ this._currentId = 0;
+ this._microtaskId = 1;
+ this._animationCallbacksBuffer = [];
+ this._rendererCache = new Map();
+ engine.onRemovalComplete = function (element, delegate) {
+ // Note: if an component element has a leave animation, and the component
+ // a host leave animation, the view engine will call `removeChild` for the parent
+ // component renderer as well as for the child component renderer.
+ // Therefore, we need to check if we already removed the element.
+ if (delegate && delegate.parentNode(element)) {
+ delegate.removeChild(element.parentNode, element);
+ }
+ };
+ }
+ /**
+ * @param {?} hostElement
+ * @param {?} type
+ * @return {?}
+ */
+ AnimationRendererFactory.prototype.createRenderer = function (hostElement, type) {
+ var _this = this;
+ var /** @type {?} */ EMPTY_NAMESPACE_ID = '';
+ // cache the delegates to find out which cached delegate can
+ // be used by which cached renderer
+ var /** @type {?} */ delegate = this.delegate.createRenderer(hostElement, type);
+ if (!hostElement || !type || !type.data || !type.data['animation']) {
+ var /** @type {?} */ renderer = this._rendererCache.get(delegate);
+ if (!renderer) {
+ renderer = new BaseAnimationRenderer(EMPTY_NAMESPACE_ID, delegate, this.engine);
+ // only cache this result when the base renderer is used
+ this._rendererCache.set(delegate, renderer);
+ }
+ return renderer;
+ }
+ var /** @type {?} */ componentId = type.id;
+ var /** @type {?} */ namespaceId = type.id + '-' + this._currentId;
+ this._currentId++;
+ this.engine.register(namespaceId, hostElement);
+ var /** @type {?} */ animationTriggers = (type.data['animation']);
+ animationTriggers.forEach(function (trigger) { return _this.engine.registerTrigger(componentId, namespaceId, hostElement, trigger.name, trigger); });
+ return new AnimationRenderer(this, namespaceId, delegate, this.engine);
+ };
+ /**
+ * @return {?}
+ */
+ AnimationRendererFactory.prototype.begin = function () {
+ if (this.delegate.begin) {
+ this.delegate.begin();
+ }
+ };
+ /**
+ * @return {?}
+ */
+ AnimationRendererFactory.prototype._scheduleCountTask = function () {
+ var _this = this;
+ Zone.current.scheduleMicroTask('incremenet the animation microtask', function () { return _this._microtaskId++; });
+ };
+ /**
+ * @param {?} count
+ * @param {?} fn
+ * @param {?} data
+ * @return {?}
+ */
+ AnimationRendererFactory.prototype.scheduleListenerCallback = function (count, fn, data) {
+ var _this = this;
+ if (count >= 0 && count < this._microtaskId) {
+ this._zone.run(function () { return fn(data); });
+ return;
+ }
+ if (this._animationCallbacksBuffer.length == 0) {
+ Promise.resolve(null).then(function () {
+ _this._zone.run(function () {
+ _this._animationCallbacksBuffer.forEach(function (tuple) {
+ var fn = tuple[0], data = tuple[1];
+ fn(data);
+ });
+ _this._animationCallbacksBuffer = [];
+ });
+ });
+ }
+ this._animationCallbacksBuffer.push([fn, data]);
+ };
+ /**
+ * @return {?}
+ */
+ AnimationRendererFactory.prototype.end = function () {
+ var _this = this;
+ this._zone.runOutsideAngular(function () {
+ _this._scheduleCountTask();
+ _this.engine.flush(_this._microtaskId);
+ });
+ if (this.delegate.end) {
+ this.delegate.end();
+ }
+ };
+ /**
+ * @return {?}
+ */
+ AnimationRendererFactory.prototype.whenRenderingDone = function () { return this.engine.whenRenderingDone(); };
+ return AnimationRendererFactory;
+}());
+AnimationRendererFactory.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+AnimationRendererFactory.ctorParameters = function () { return [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["RendererFactory2"], },
+ { type: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["b" /* ɵAnimationEngine */], },
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["NgZone"], },
+]; };
+var BaseAnimationRenderer = (function () {
+ /**
+ * @param {?} namespaceId
+ * @param {?} delegate
+ * @param {?} engine
+ */
+ function BaseAnimationRenderer(namespaceId, delegate, engine) {
+ this.namespaceId = namespaceId;
+ this.delegate = delegate;
+ this.engine = engine;
+ this.destroyNode = this.delegate.destroyNode ? function (n) { return delegate.destroyNode(n); } : null;
+ }
+ Object.defineProperty(BaseAnimationRenderer.prototype, "data", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this.delegate.data; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.destroy = function () {
+ this.engine.destroy(this.namespaceId, this.delegate);
+ this.delegate.destroy();
+ };
+ /**
+ * @param {?} name
+ * @param {?=} namespace
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.createElement = function (name, namespace) {
+ return this.delegate.createElement(name, namespace);
+ };
+ /**
+ * @param {?} value
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.createComment = function (value) { return this.delegate.createComment(value); };
+ /**
+ * @param {?} value
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.createText = function (value) { return this.delegate.createText(value); };
+ /**
+ * @param {?} parent
+ * @param {?} newChild
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.appendChild = function (parent, newChild) {
+ this.delegate.appendChild(parent, newChild);
+ this.engine.onInsert(this.namespaceId, newChild, parent, false);
+ };
+ /**
+ * @param {?} parent
+ * @param {?} newChild
+ * @param {?} refChild
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.insertBefore = function (parent, newChild, refChild) {
+ this.delegate.insertBefore(parent, newChild, refChild);
+ this.engine.onInsert(this.namespaceId, newChild, parent, true);
+ };
+ /**
+ * @param {?} parent
+ * @param {?} oldChild
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.removeChild = function (parent, oldChild) {
+ this.engine.onRemove(this.namespaceId, oldChild, this.delegate);
+ };
+ /**
+ * @param {?} selectorOrNode
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.selectRootElement = function (selectorOrNode) { return this.delegate.selectRootElement(selectorOrNode); };
+ /**
+ * @param {?} node
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.parentNode = function (node) { return this.delegate.parentNode(node); };
+ /**
+ * @param {?} node
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.nextSibling = function (node) { return this.delegate.nextSibling(node); };
+ /**
+ * @param {?} el
+ * @param {?} name
+ * @param {?} value
+ * @param {?=} namespace
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.setAttribute = function (el, name, value, namespace) {
+ this.delegate.setAttribute(el, name, value, namespace);
+ };
+ /**
+ * @param {?} el
+ * @param {?} name
+ * @param {?=} namespace
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.removeAttribute = function (el, name, namespace) {
+ this.delegate.removeAttribute(el, name, namespace);
+ };
+ /**
+ * @param {?} el
+ * @param {?} name
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.addClass = function (el, name) { this.delegate.addClass(el, name); };
+ /**
+ * @param {?} el
+ * @param {?} name
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.removeClass = function (el, name) { this.delegate.removeClass(el, name); };
+ /**
+ * @param {?} el
+ * @param {?} style
+ * @param {?} value
+ * @param {?=} flags
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.setStyle = function (el, style, value, flags) {
+ this.delegate.setStyle(el, style, value, flags);
+ };
+ /**
+ * @param {?} el
+ * @param {?} style
+ * @param {?=} flags
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.removeStyle = function (el, style, flags) {
+ this.delegate.removeStyle(el, style, flags);
+ };
+ /**
+ * @param {?} el
+ * @param {?} name
+ * @param {?} value
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.setProperty = function (el, name, value) {
+ this.delegate.setProperty(el, name, value);
+ };
+ /**
+ * @param {?} node
+ * @param {?} value
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.setValue = function (node, value) { this.delegate.setValue(node, value); };
+ /**
+ * @param {?} target
+ * @param {?} eventName
+ * @param {?} callback
+ * @return {?}
+ */
+ BaseAnimationRenderer.prototype.listen = function (target, eventName, callback) {
+ return this.delegate.listen(target, eventName, callback);
+ };
+ return BaseAnimationRenderer;
+}());
+var AnimationRenderer = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](AnimationRenderer, _super);
+ /**
+ * @param {?} factory
+ * @param {?} namespaceId
+ * @param {?} delegate
+ * @param {?} engine
+ */
+ function AnimationRenderer(factory, namespaceId, delegate, engine) {
+ var _this = _super.call(this, namespaceId, delegate, engine) || this;
+ _this.factory = factory;
+ _this.namespaceId = namespaceId;
+ return _this;
+ }
+ /**
+ * @param {?} el
+ * @param {?} name
+ * @param {?} value
+ * @return {?}
+ */
+ AnimationRenderer.prototype.setProperty = function (el, name, value) {
+ if (name.charAt(0) == '@') {
+ name = name.substr(1);
+ this.engine.setProperty(this.namespaceId, el, name, value);
+ }
+ else {
+ this.delegate.setProperty(el, name, value);
+ }
+ };
+ /**
+ * @param {?} target
+ * @param {?} eventName
+ * @param {?} callback
+ * @return {?}
+ */
+ AnimationRenderer.prototype.listen = function (target, eventName, callback) {
+ var _this = this;
+ if (eventName.charAt(0) == '@') {
+ var /** @type {?} */ element = resolveElementFromTarget(target);
+ var /** @type {?} */ name = eventName.substr(1);
+ var /** @type {?} */ phase = '';
+ if (name.charAt(0) != '@') {
+ _a = parseTriggerCallbackName(name), name = _a[0], phase = _a[1];
+ }
+ return this.engine.listen(this.namespaceId, element, name, phase, function (event) {
+ var /** @type {?} */ countId = ((event))['_data'] || -1;
+ _this.factory.scheduleListenerCallback(countId, callback, event);
+ });
+ }
+ return this.delegate.listen(target, eventName, callback);
+ var _a;
+ };
+ return AnimationRenderer;
+}(BaseAnimationRenderer));
+/**
+ * @param {?} target
+ * @return {?}
+ */
+function resolveElementFromTarget(target) {
+ switch (target) {
+ case 'body':
+ return document.body;
+ case 'document':
+ return document;
+ case 'window':
+ return window;
+ default:
+ return target;
+ }
+}
+/**
+ * @param {?} triggerName
+ * @return {?}
+ */
+function parseTriggerCallbackName(triggerName) {
+ var /** @type {?} */ dotIndex = triggerName.indexOf('.');
+ var /** @type {?} */ trigger = triggerName.substring(0, dotIndex);
+ var /** @type {?} */ phase = triggerName.substr(dotIndex + 1);
+ return [trigger, phase];
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var InjectableAnimationEngine = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](InjectableAnimationEngine, _super);
+ /**
+ * @param {?} driver
+ * @param {?} normalizer
+ */
+ function InjectableAnimationEngine(driver, normalizer) {
+ return _super.call(this, driver, normalizer) || this;
+ }
+ return InjectableAnimationEngine;
+}(__WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["b" /* ɵAnimationEngine */]));
+InjectableAnimationEngine.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["Injectable"] },
+];
+/**
+ * @nocollapse
+ */
+InjectableAnimationEngine.ctorParameters = function () { return [
+ { type: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["a" /* AnimationDriver */], },
+ { type: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["c" /* ɵAnimationStyleNormalizer */], },
+]; };
+/**
+ * @return {?}
+ */
+function instantiateSupportedAnimationDriver() {
+ if (__WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["g" /* ɵsupportsWebAnimations */]()) {
+ return new __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["e" /* ɵWebAnimationsDriver */]();
+ }
+ return new __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["d" /* ɵNoopAnimationDriver */]();
+}
+/**
+ * @return {?}
+ */
+function instantiateDefaultStyleNormalizer() {
+ return new __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["f" /* ɵWebAnimationsStyleNormalizer */]();
+}
+/**
+ * @param {?} renderer
+ * @param {?} engine
+ * @param {?} zone
+ * @return {?}
+ */
+function instantiateRendererFactory(renderer, engine, zone) {
+ return new AnimationRendererFactory(renderer, engine, zone);
+}
+var SHARED_ANIMATION_PROVIDERS = [
+ { provide: __WEBPACK_IMPORTED_MODULE_3__angular_animations__["AnimationBuilder"], useClass: BrowserAnimationBuilder },
+ { provide: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["c" /* ɵAnimationStyleNormalizer */], useFactory: instantiateDefaultStyleNormalizer },
+ { provide: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["b" /* ɵAnimationEngine */], useClass: InjectableAnimationEngine }, {
+ provide: __WEBPACK_IMPORTED_MODULE_1__angular_core__["RendererFactory2"],
+ useFactory: instantiateRendererFactory,
+ deps: [__WEBPACK_IMPORTED_MODULE_2__angular_platform_browser__["ɵDomRendererFactory2"], __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["b" /* ɵAnimationEngine */], __WEBPACK_IMPORTED_MODULE_1__angular_core__["NgZone"]]
+ }
+];
+/**
+ * Separate providers from the actual module so that we can do a local modification in Google3 to
+ * include them in the BrowserModule.
+ */
+var BROWSER_ANIMATIONS_PROVIDERS = [
+ { provide: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["a" /* AnimationDriver */], useFactory: instantiateSupportedAnimationDriver }
+].concat(SHARED_ANIMATION_PROVIDERS);
+/**
+ * Separate providers from the actual module so that we can do a local modification in Google3 to
+ * include them in the BrowserTestingModule.
+ */
+var BROWSER_NOOP_ANIMATIONS_PROVIDERS = [{ provide: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["a" /* AnimationDriver */], useClass: __WEBPACK_IMPORTED_MODULE_4__angular_animations_browser__["d" /* ɵNoopAnimationDriver */] }].concat(SHARED_ANIMATION_PROVIDERS);
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * \@experimental Animation support is experimental.
+ */
+var BrowserAnimationsModule = (function () {
+ function BrowserAnimationsModule() {
+ }
+ return BrowserAnimationsModule;
+}());
+BrowserAnimationsModule.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["NgModule"], args: [{
+ imports: [__WEBPACK_IMPORTED_MODULE_2__angular_platform_browser__["BrowserModule"]],
+ providers: BROWSER_ANIMATIONS_PROVIDERS,
+ },] },
+];
+/**
+ * @nocollapse
+ */
+BrowserAnimationsModule.ctorParameters = function () { return []; };
+/**
+ * \@experimental Animation support is experimental.
+ */
+var NoopAnimationsModule = (function () {
+ function NoopAnimationsModule() {
+ }
+ return NoopAnimationsModule;
+}());
+NoopAnimationsModule.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_1__angular_core__["NgModule"], args: [{
+ imports: [__WEBPACK_IMPORTED_MODULE_2__angular_platform_browser__["BrowserModule"]],
+ providers: BROWSER_NOOP_ANIMATIONS_PROVIDERS,
+ },] },
+];
+/**
+ * @nocollapse
+ */
+NoopAnimationsModule.ctorParameters = function () { return []; };
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all animation APIs of the animation browser package.
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the animation package.
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+//# sourceMappingURL=animations.es5.js.map
+
+
+/***/ }),
+/* 594 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return AnimationDriver; });
+/* unused harmony export ɵAnimation */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return AnimationStyleNormalizer; });
+/* unused harmony export ɵNoopAnimationStyleNormalizer */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return WebAnimationsStyleNormalizer; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return NoopAnimationDriver; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return AnimationEngine; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return WebAnimationsDriver; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return supportsWebAnimations; });
+/* unused harmony export ɵWebAnimationsPlayer */
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tslib__ = __webpack_require__(29);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_animations__ = __webpack_require__(33);
+
+/**
+ * @license Angular v4.2.6
+ * (c) 2010-2017 Google, Inc. https://angular.io/
+ * License: MIT
+ */
+
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+function optimizeGroupPlayer(players) {
+ switch (players.length) {
+ case 0:
+ return new __WEBPACK_IMPORTED_MODULE_1__angular_animations__["NoopAnimationPlayer"]();
+ case 1:
+ return players[0];
+ default:
+ return new __WEBPACK_IMPORTED_MODULE_1__angular_animations__["ɵAnimationGroupPlayer"](players);
+ }
+}
+function normalizeKeyframes(driver, normalizer, element, keyframes, preStyles, postStyles) {
+ if (preStyles === void 0) { preStyles = {}; }
+ if (postStyles === void 0) { postStyles = {}; }
+ var errors = [];
+ var normalizedKeyframes = [];
+ var previousOffset = -1;
+ var previousKeyframe = null;
+ keyframes.forEach(function (kf) {
+ var offset = kf['offset'];
+ var isSameOffset = offset == previousOffset;
+ var normalizedKeyframe = (isSameOffset && previousKeyframe) || {};
+ Object.keys(kf).forEach(function (prop) {
+ var normalizedProp = prop;
+ var normalizedValue = kf[prop];
+ if (normalizedValue == __WEBPACK_IMPORTED_MODULE_1__angular_animations__["ɵPRE_STYLE"]) {
+ normalizedValue = preStyles[prop];
+ }
+ else if (normalizedValue == __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"]) {
+ normalizedValue = postStyles[prop];
+ }
+ else if (prop != 'offset') {
+ normalizedProp = normalizer.normalizePropertyName(prop, errors);
+ normalizedValue = normalizer.normalizeStyleValue(prop, normalizedProp, kf[prop], errors);
+ }
+ normalizedKeyframe[normalizedProp] = normalizedValue;
+ });
+ if (!isSameOffset) {
+ normalizedKeyframes.push(normalizedKeyframe);
+ }
+ previousKeyframe = normalizedKeyframe;
+ previousOffset = offset;
+ });
+ if (errors.length) {
+ var LINE_START = '\n - ';
+ throw new Error("Unable to animate due to the following errors:" + LINE_START + errors.join(LINE_START));
+ }
+ return normalizedKeyframes;
+}
+function listenOnPlayer(player, eventName, event, callback) {
+ switch (eventName) {
+ case 'start':
+ player.onStart(function () { return callback(event && copyAnimationEvent(event, 'start', player.totalTime)); });
+ break;
+ case 'done':
+ player.onDone(function () { return callback(event && copyAnimationEvent(event, 'done', player.totalTime)); });
+ break;
+ case 'destroy':
+ player.onDestroy(function () { return callback(event && copyAnimationEvent(event, 'destroy', player.totalTime)); });
+ break;
+ }
+}
+function copyAnimationEvent(e, phaseName, totalTime) {
+ var event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime);
+ var data = e['_data'];
+ if (data != null) {
+ event['_data'] = data;
+ }
+ return event;
+}
+function makeAnimationEvent(element, triggerName, fromState, toState, phaseName, totalTime) {
+ if (phaseName === void 0) { phaseName = ''; }
+ if (totalTime === void 0) { totalTime = 0; }
+ return { element: element, triggerName: triggerName, fromState: fromState, toState: toState, phaseName: phaseName, totalTime: totalTime };
+}
+function getOrSetAsInMap(map, key, defaultValue) {
+ var value;
+ if (map instanceof Map) {
+ value = map.get(key);
+ if (!value) {
+ map.set(key, value = defaultValue);
+ }
+ }
+ else {
+ value = map[key];
+ if (!value) {
+ value = map[key] = defaultValue;
+ }
+ }
+ return value;
+}
+function parseTimelineCommand(command) {
+ var separatorPos = command.indexOf(':');
+ var id = command.substring(1, separatorPos);
+ var action = command.substr(separatorPos + 1);
+ return [id, action];
+}
+var _contains = function (elm1, elm2) { return false; };
+var _matches = function (element, selector) { return false; };
+var _query = function (element, selector, multi) {
+ return [];
+};
+if (typeof Element != 'undefined') {
+ // this is well supported in all browsers
+ _contains = function (elm1, elm2) { return elm1.contains(elm2); };
+ if (Element.prototype.matches) {
+ _matches = function (element, selector) { return element.matches(selector); };
+ }
+ else {
+ var proto = Element.prototype;
+ var fn_1 = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector ||
+ proto.oMatchesSelector || proto.webkitMatchesSelector;
+ if (fn_1) {
+ _matches = function (element, selector) { return fn_1.apply(element, [selector]); };
+ }
+ }
+ _query = function (element, selector, multi) {
+ var results = [];
+ if (multi) {
+ results.push.apply(results, element.querySelectorAll(selector));
+ }
+ else {
+ var elm = element.querySelector(selector);
+ if (elm) {
+ results.push(elm);
+ }
+ }
+ return results;
+ };
+}
+var matchesElement = _matches;
+var containsElement = _contains;
+var invokeQuery = _query;
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @experimental
+ */
+var NoopAnimationDriver = (function () {
+ function NoopAnimationDriver() {
+ }
+ NoopAnimationDriver.prototype.matchesElement = function (element, selector) {
+ return matchesElement(element, selector);
+ };
+ NoopAnimationDriver.prototype.containsElement = function (elm1, elm2) { return containsElement(elm1, elm2); };
+ NoopAnimationDriver.prototype.query = function (element, selector, multi) {
+ return invokeQuery(element, selector, multi);
+ };
+ NoopAnimationDriver.prototype.computeStyle = function (element, prop, defaultValue) {
+ return defaultValue || '';
+ };
+ NoopAnimationDriver.prototype.animate = function (element, keyframes, duration, delay, easing, previousPlayers) {
+ if (previousPlayers === void 0) { previousPlayers = []; }
+ return new __WEBPACK_IMPORTED_MODULE_1__angular_animations__["NoopAnimationPlayer"]();
+ };
+ return NoopAnimationDriver;
+}());
+/**
+ * @experimental
+ */
+var AnimationDriver = (function () {
+ function AnimationDriver() {
+ }
+ return AnimationDriver;
+}());
+AnimationDriver.NOOP = new NoopAnimationDriver();
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var ONE_SECOND = 1000;
+var ENTER_CLASSNAME = 'ng-enter';
+var LEAVE_CLASSNAME = 'ng-leave';
+var ENTER_SELECTOR = '.ng-enter';
+var LEAVE_SELECTOR = '.ng-leave';
+var NG_TRIGGER_CLASSNAME = 'ng-trigger';
+var NG_TRIGGER_SELECTOR = '.ng-trigger';
+var NG_ANIMATING_CLASSNAME = 'ng-animating';
+var NG_ANIMATING_SELECTOR = '.ng-animating';
+function resolveTimingValue(value) {
+ if (typeof value == 'number')
+ return value;
+ var matches = value.match(/^(-?[\.\d]+)(m?s)/);
+ if (!matches || matches.length < 2)
+ return 0;
+ return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+}
+function _convertTimeValueToMS(value, unit) {
+ switch (unit) {
+ case 's':
+ return value * ONE_SECOND;
+ default:
+ return value;
+ }
+}
+function resolveTiming(timings, errors, allowNegativeValues) {
+ return timings.hasOwnProperty('duration') ?
+ timings :
+ parseTimeExpression(timings, errors, allowNegativeValues);
+}
+function parseTimeExpression(exp, errors, allowNegativeValues) {
+ var regex = /^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i;
+ var duration;
+ var delay = 0;
+ var easing = '';
+ if (typeof exp === 'string') {
+ var matches = exp.match(regex);
+ if (matches === null) {
+ errors.push("The provided timing value \"" + exp + "\" is invalid.");
+ return { duration: 0, delay: 0, easing: '' };
+ }
+ duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]);
+ var delayMatch = matches[3];
+ if (delayMatch != null) {
+ delay = _convertTimeValueToMS(Math.floor(parseFloat(delayMatch)), matches[4]);
+ }
+ var easingVal = matches[5];
+ if (easingVal) {
+ easing = easingVal;
+ }
+ }
+ else {
+ duration = exp;
+ }
+ if (!allowNegativeValues) {
+ var containsErrors = false;
+ var startIndex = errors.length;
+ if (duration < 0) {
+ errors.push("Duration values below 0 are not allowed for this animation step.");
+ containsErrors = true;
+ }
+ if (delay < 0) {
+ errors.push("Delay values below 0 are not allowed for this animation step.");
+ containsErrors = true;
+ }
+ if (containsErrors) {
+ errors.splice(startIndex, 0, "The provided timing value \"" + exp + "\" is invalid.");
+ }
+ }
+ return { duration: duration, delay: delay, easing: easing };
+}
+function copyObj(obj, destination) {
+ if (destination === void 0) { destination = {}; }
+ Object.keys(obj).forEach(function (prop) { destination[prop] = obj[prop]; });
+ return destination;
+}
+function normalizeStyles(styles) {
+ var normalizedStyles = {};
+ if (Array.isArray(styles)) {
+ styles.forEach(function (data) { return copyStyles(data, false, normalizedStyles); });
+ }
+ else {
+ copyStyles(styles, false, normalizedStyles);
+ }
+ return normalizedStyles;
+}
+function copyStyles(styles, readPrototype, destination) {
+ if (destination === void 0) { destination = {}; }
+ if (readPrototype) {
+ // we make use of a for-in loop so that the
+ // prototypically inherited properties are
+ // revealed from the backFill map
+ for (var prop in styles) {
+ destination[prop] = styles[prop];
+ }
+ }
+ else {
+ copyObj(styles, destination);
+ }
+ return destination;
+}
+function setStyles(element, styles) {
+ if (element['style']) {
+ Object.keys(styles).forEach(function (prop) {
+ var camelProp = dashCaseToCamelCase(prop);
+ element.style[camelProp] = styles[prop];
+ });
+ }
+}
+function eraseStyles(element, styles) {
+ if (element['style']) {
+ Object.keys(styles).forEach(function (prop) {
+ var camelProp = dashCaseToCamelCase(prop);
+ element.style[camelProp] = '';
+ });
+ }
+}
+function normalizeAnimationEntry(steps) {
+ if (Array.isArray(steps)) {
+ if (steps.length == 1)
+ return steps[0];
+ return __WEBPACK_IMPORTED_MODULE_1__angular_animations__["sequence"](steps);
+ }
+ return steps;
+}
+function validateStyleParams(value, options, errors) {
+ var params = options.params || {};
+ if (typeof value !== 'string')
+ return;
+ var matches = value.toString().match(PARAM_REGEX);
+ if (matches) {
+ matches.forEach(function (varName) {
+ if (!params.hasOwnProperty(varName)) {
+ errors.push("Unable to resolve the local animation param " + varName + " in the given list of values");
+ }
+ });
+ }
+}
+var PARAM_REGEX = /\{\{\s*(.+?)\s*\}\}/g;
+function interpolateParams(value, params, errors) {
+ var original = value.toString();
+ var str = original.replace(PARAM_REGEX, function (_, varName) {
+ var localVal = params[varName];
+ // this means that the value was never overidden by the data passed in by the user
+ if (!params.hasOwnProperty(varName)) {
+ errors.push("Please provide a value for the animation param " + varName);
+ localVal = '';
+ }
+ return localVal.toString();
+ });
+ // we do this to assert that numeric values stay as they are
+ return str == original ? value : str;
+}
+function iteratorToArray(iterator) {
+ var arr = [];
+ var item = iterator.next();
+ while (!item.done) {
+ arr.push(item.value);
+ item = iterator.next();
+ }
+ return arr;
+}
+function mergeAnimationOptions(source, destination) {
+ if (source.params) {
+ var p0_1 = source.params;
+ if (!destination.params) {
+ destination.params = {};
+ }
+ var p1_1 = destination.params;
+ Object.keys(p0_1).forEach(function (param) {
+ if (!p1_1.hasOwnProperty(param)) {
+ p1_1[param] = p0_1[param];
+ }
+ });
+ }
+ return destination;
+}
+var DASH_CASE_REGEXP = /-+([a-z0-9])/g;
+function dashCaseToCamelCase(input) {
+ return input.replace(DASH_CASE_REGEXP, function () {
+ var m = [];
+ for (var _i = 0; _i < arguments.length; _i++) {
+ m[_i] = arguments[_i];
+ }
+ return m[1].toUpperCase();
+ });
+}
+function allowPreviousPlayerStylesMerge(duration, delay) {
+ return duration === 0 || delay === 0;
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var EMPTY_ANIMATION_OPTIONS = {};
+/**
+ * @abstract
+ */
+var Ast = (function () {
+ function Ast() {
+ this.options = EMPTY_ANIMATION_OPTIONS;
+ }
+ /**
+ * @abstract
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ Ast.prototype.visit = function (ast, context) { };
+ Object.defineProperty(Ast.prototype, "params", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this.options['params'] || null; },
+ enumerable: true,
+ configurable: true
+ });
+ return Ast;
+}());
+var TriggerAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](TriggerAst, _super);
+ /**
+ * @param {?} name
+ * @param {?} states
+ * @param {?} transitions
+ */
+ function TriggerAst(name, states, transitions) {
+ var _this = _super.call(this) || this;
+ _this.name = name;
+ _this.states = states;
+ _this.transitions = transitions;
+ _this.queryCount = 0;
+ _this.depCount = 0;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ TriggerAst.prototype.visit = function (visitor, context) { return visitor.visitTrigger(this, context); };
+ return TriggerAst;
+}(Ast));
+var StateAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](StateAst, _super);
+ /**
+ * @param {?} name
+ * @param {?} style
+ */
+ function StateAst(name, style$$1) {
+ var _this = _super.call(this) || this;
+ _this.name = name;
+ _this.style = style$$1;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ StateAst.prototype.visit = function (visitor, context) { return visitor.visitState(this, context); };
+ return StateAst;
+}(Ast));
+var TransitionAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](TransitionAst, _super);
+ /**
+ * @param {?} matchers
+ * @param {?} animation
+ */
+ function TransitionAst(matchers, animation) {
+ var _this = _super.call(this) || this;
+ _this.matchers = matchers;
+ _this.animation = animation;
+ _this.queryCount = 0;
+ _this.depCount = 0;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ TransitionAst.prototype.visit = function (visitor, context) { return visitor.visitTransition(this, context); };
+ return TransitionAst;
+}(Ast));
+var SequenceAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](SequenceAst, _super);
+ /**
+ * @param {?} steps
+ */
+ function SequenceAst(steps) {
+ var _this = _super.call(this) || this;
+ _this.steps = steps;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ SequenceAst.prototype.visit = function (visitor, context) { return visitor.visitSequence(this, context); };
+ return SequenceAst;
+}(Ast));
+var GroupAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](GroupAst, _super);
+ /**
+ * @param {?} steps
+ */
+ function GroupAst(steps) {
+ var _this = _super.call(this) || this;
+ _this.steps = steps;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ GroupAst.prototype.visit = function (visitor, context) { return visitor.visitGroup(this, context); };
+ return GroupAst;
+}(Ast));
+var AnimateAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](AnimateAst, _super);
+ /**
+ * @param {?} timings
+ * @param {?} style
+ */
+ function AnimateAst(timings, style$$1) {
+ var _this = _super.call(this) || this;
+ _this.timings = timings;
+ _this.style = style$$1;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ AnimateAst.prototype.visit = function (visitor, context) { return visitor.visitAnimate(this, context); };
+ return AnimateAst;
+}(Ast));
+var StyleAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](StyleAst, _super);
+ /**
+ * @param {?} styles
+ * @param {?} easing
+ * @param {?} offset
+ */
+ function StyleAst(styles, easing, offset) {
+ var _this = _super.call(this) || this;
+ _this.styles = styles;
+ _this.easing = easing;
+ _this.offset = offset;
+ _this.isEmptyStep = false;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ StyleAst.prototype.visit = function (visitor, context) { return visitor.visitStyle(this, context); };
+ return StyleAst;
+}(Ast));
+var KeyframesAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](KeyframesAst, _super);
+ /**
+ * @param {?} styles
+ */
+ function KeyframesAst(styles) {
+ var _this = _super.call(this) || this;
+ _this.styles = styles;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ KeyframesAst.prototype.visit = function (visitor, context) { return visitor.visitKeyframes(this, context); };
+ return KeyframesAst;
+}(Ast));
+var ReferenceAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](ReferenceAst, _super);
+ /**
+ * @param {?} animation
+ */
+ function ReferenceAst(animation) {
+ var _this = _super.call(this) || this;
+ _this.animation = animation;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ ReferenceAst.prototype.visit = function (visitor, context) { return visitor.visitReference(this, context); };
+ return ReferenceAst;
+}(Ast));
+var AnimateChildAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](AnimateChildAst, _super);
+ function AnimateChildAst() {
+ return _super.call(this) || this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ AnimateChildAst.prototype.visit = function (visitor, context) { return visitor.visitAnimateChild(this, context); };
+ return AnimateChildAst;
+}(Ast));
+var AnimateRefAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](AnimateRefAst, _super);
+ /**
+ * @param {?} animation
+ */
+ function AnimateRefAst(animation) {
+ var _this = _super.call(this) || this;
+ _this.animation = animation;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ AnimateRefAst.prototype.visit = function (visitor, context) { return visitor.visitAnimateRef(this, context); };
+ return AnimateRefAst;
+}(Ast));
+var QueryAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](QueryAst, _super);
+ /**
+ * @param {?} selector
+ * @param {?} limit
+ * @param {?} optional
+ * @param {?} includeSelf
+ * @param {?} animation
+ */
+ function QueryAst(selector, limit, optional, includeSelf, animation) {
+ var _this = _super.call(this) || this;
+ _this.selector = selector;
+ _this.limit = limit;
+ _this.optional = optional;
+ _this.includeSelf = includeSelf;
+ _this.animation = animation;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ QueryAst.prototype.visit = function (visitor, context) { return visitor.visitQuery(this, context); };
+ return QueryAst;
+}(Ast));
+var StaggerAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](StaggerAst, _super);
+ /**
+ * @param {?} timings
+ * @param {?} animation
+ */
+ function StaggerAst(timings, animation) {
+ var _this = _super.call(this) || this;
+ _this.timings = timings;
+ _this.animation = animation;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ StaggerAst.prototype.visit = function (visitor, context) { return visitor.visitStagger(this, context); };
+ return StaggerAst;
+}(Ast));
+var TimingAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](TimingAst, _super);
+ /**
+ * @param {?} duration
+ * @param {?=} delay
+ * @param {?=} easing
+ */
+ function TimingAst(duration, delay, easing) {
+ if (delay === void 0) { delay = 0; }
+ if (easing === void 0) { easing = null; }
+ var _this = _super.call(this) || this;
+ _this.duration = duration;
+ _this.delay = delay;
+ _this.easing = easing;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ TimingAst.prototype.visit = function (visitor, context) { return visitor.visitTiming(this, context); };
+ return TimingAst;
+}(Ast));
+var DynamicTimingAst = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](DynamicTimingAst, _super);
+ /**
+ * @param {?} value
+ */
+ function DynamicTimingAst(value) {
+ var _this = _super.call(this, 0, 0, '') || this;
+ _this.value = value;
+ return _this;
+ }
+ /**
+ * @param {?} visitor
+ * @param {?} context
+ * @return {?}
+ */
+ DynamicTimingAst.prototype.visit = function (visitor, context) { return visitor.visitTiming(this, context); };
+ return DynamicTimingAst;
+}(TimingAst));
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @param {?} visitor
+ * @param {?} node
+ * @param {?} context
+ * @return {?}
+ */
+function visitAnimationNode(visitor, node, context) {
+ switch (node.type) {
+ case 7 /* Trigger */:
+ return visitor.visitTrigger(/** @type {?} */ (node), context);
+ case 0 /* State */:
+ return visitor.visitState(/** @type {?} */ (node), context);
+ case 1 /* Transition */:
+ return visitor.visitTransition(/** @type {?} */ (node), context);
+ case 2 /* Sequence */:
+ return visitor.visitSequence(/** @type {?} */ (node), context);
+ case 3 /* Group */:
+ return visitor.visitGroup(/** @type {?} */ (node), context);
+ case 4 /* Animate */:
+ return visitor.visitAnimate(/** @type {?} */ (node), context);
+ case 5 /* Keyframes */:
+ return visitor.visitKeyframes(/** @type {?} */ (node), context);
+ case 6 /* Style */:
+ return visitor.visitStyle(/** @type {?} */ (node), context);
+ case 8 /* Reference */:
+ return visitor.visitReference(/** @type {?} */ (node), context);
+ case 9 /* AnimateChild */:
+ return visitor.visitAnimateChild(/** @type {?} */ (node), context);
+ case 10 /* AnimateRef */:
+ return visitor.visitAnimateRef(/** @type {?} */ (node), context);
+ case 11 /* Query */:
+ return visitor.visitQuery(/** @type {?} */ (node), context);
+ case 12 /* Stagger */:
+ return visitor.visitStagger(/** @type {?} */ (node), context);
+ default:
+ throw new Error("Unable to resolve animation metadata node #" + node.type);
+ }
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var ANY_STATE = '*';
+/**
+ * @param {?} transitionValue
+ * @param {?} errors
+ * @return {?}
+ */
+function parseTransitionExpr(transitionValue, errors) {
+ var /** @type {?} */ expressions = [];
+ if (typeof transitionValue == 'string') {
+ ((transitionValue))
+ .split(/\s*,\s*/)
+ .forEach(function (str) { return parseInnerTransitionStr(str, expressions, errors); });
+ }
+ else {
+ expressions.push(/** @type {?} */ (transitionValue));
+ }
+ return expressions;
+}
+/**
+ * @param {?} eventStr
+ * @param {?} expressions
+ * @param {?} errors
+ * @return {?}
+ */
+function parseInnerTransitionStr(eventStr, expressions, errors) {
+ if (eventStr[0] == ':') {
+ eventStr = parseAnimationAlias(eventStr, errors);
+ }
+ var /** @type {?} */ match = eventStr.match(/^(\*|[-\w]+)\s*()\s*(\*|[-\w]+)$/);
+ if (match == null || match.length < 4) {
+ errors.push("The provided transition expression \"" + eventStr + "\" is not supported");
+ return expressions;
+ }
+ var /** @type {?} */ fromState = match[1];
+ var /** @type {?} */ separator = match[2];
+ var /** @type {?} */ toState = match[3];
+ expressions.push(makeLambdaFromStates(fromState, toState));
+ var /** @type {?} */ isFullAnyStateExpr = fromState == ANY_STATE && toState == ANY_STATE;
+ if (separator[0] == '<' && !isFullAnyStateExpr) {
+ expressions.push(makeLambdaFromStates(toState, fromState));
+ }
+}
+/**
+ * @param {?} alias
+ * @param {?} errors
+ * @return {?}
+ */
+function parseAnimationAlias(alias, errors) {
+ switch (alias) {
+ case ':enter':
+ return 'void => *';
+ case ':leave':
+ return '* => void';
+ default:
+ errors.push("The transition alias value \"" + alias + "\" is not supported");
+ return '* => *';
+ }
+}
+/**
+ * @param {?} lhs
+ * @param {?} rhs
+ * @return {?}
+ */
+function makeLambdaFromStates(lhs, rhs) {
+ return function (fromState, toState) {
+ var /** @type {?} */ lhsMatch = lhs == ANY_STATE || lhs == fromState;
+ var /** @type {?} */ rhsMatch = rhs == ANY_STATE || rhs == toState;
+ if (!lhsMatch && typeof fromState === 'boolean') {
+ lhsMatch = fromState ? lhs === 'true' : lhs === 'false';
+ }
+ if (!rhsMatch && typeof toState === 'boolean') {
+ rhsMatch = toState ? rhs === 'true' : rhs === 'false';
+ }
+ return lhsMatch && rhsMatch;
+ };
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var SELF_TOKEN = ':self';
+var SELF_TOKEN_REGEX = new RegExp("s*" + SELF_TOKEN + "s*,?", 'g');
+/**
+ * @param {?} metadata
+ * @param {?} errors
+ * @return {?}
+ */
+function buildAnimationAst(metadata, errors) {
+ return new AnimationAstBuilderVisitor().build(metadata, errors);
+}
+var LEAVE_TOKEN = ':leave';
+var LEAVE_TOKEN_REGEX = new RegExp(LEAVE_TOKEN, 'g');
+var ENTER_TOKEN = ':enter';
+var ENTER_TOKEN_REGEX = new RegExp(ENTER_TOKEN, 'g');
+var ROOT_SELECTOR = '';
+var AnimationAstBuilderVisitor = (function () {
+ function AnimationAstBuilderVisitor() {
+ }
+ /**
+ * @param {?} metadata
+ * @param {?} errors
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.build = function (metadata, errors) {
+ var /** @type {?} */ context = new AnimationAstBuilderContext(errors);
+ this._resetContextStyleTimingState(context);
+ return (visitAnimationNode(this, normalizeAnimationEntry(metadata), context));
+ };
+ /**
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype._resetContextStyleTimingState = function (context) {
+ context.currentQuerySelector = ROOT_SELECTOR;
+ context.collectedStyles = {};
+ context.collectedStyles[ROOT_SELECTOR] = {};
+ context.currentTime = 0;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitTrigger = function (metadata, context) {
+ var _this = this;
+ var /** @type {?} */ queryCount = context.queryCount = 0;
+ var /** @type {?} */ depCount = context.depCount = 0;
+ var /** @type {?} */ states = [];
+ var /** @type {?} */ transitions = [];
+ metadata.definitions.forEach(function (def) {
+ _this._resetContextStyleTimingState(context);
+ if (def.type == 0 /* State */) {
+ var /** @type {?} */ stateDef_1 = (def);
+ var /** @type {?} */ name = stateDef_1.name;
+ name.split(/\s*,\s*/).forEach(function (n) {
+ stateDef_1.name = n;
+ states.push(_this.visitState(stateDef_1, context));
+ });
+ stateDef_1.name = name;
+ }
+ else if (def.type == 1 /* Transition */) {
+ var /** @type {?} */ transition = _this.visitTransition(/** @type {?} */ (def), context);
+ queryCount += transition.queryCount;
+ depCount += transition.depCount;
+ transitions.push(transition);
+ }
+ else {
+ context.errors.push('only state() and transition() definitions can sit inside of a trigger()');
+ }
+ });
+ var /** @type {?} */ ast = new TriggerAst(metadata.name, states, transitions);
+ ast.options = normalizeAnimationOptions(metadata.options);
+ ast.queryCount = queryCount;
+ ast.depCount = depCount;
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitState = function (metadata, context) {
+ return new StateAst(metadata.name, this.visitStyle(metadata.styles, context));
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitTransition = function (metadata, context) {
+ context.queryCount = 0;
+ context.depCount = 0;
+ var /** @type {?} */ entry = visitAnimationNode(this, normalizeAnimationEntry(metadata.animation), context);
+ var /** @type {?} */ matchers = parseTransitionExpr(metadata.expr, context.errors);
+ var /** @type {?} */ ast = new TransitionAst(matchers, entry);
+ ast.options = normalizeAnimationOptions(metadata.options);
+ ast.queryCount = context.queryCount;
+ ast.depCount = context.depCount;
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitSequence = function (metadata, context) {
+ var _this = this;
+ var /** @type {?} */ ast = new SequenceAst(metadata.steps.map(function (s) { return visitAnimationNode(_this, s, context); }));
+ ast.options = normalizeAnimationOptions(metadata.options);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitGroup = function (metadata, context) {
+ var _this = this;
+ var /** @type {?} */ currentTime = context.currentTime;
+ var /** @type {?} */ furthestTime = 0;
+ var /** @type {?} */ steps = metadata.steps.map(function (step) {
+ context.currentTime = currentTime;
+ var /** @type {?} */ innerAst = visitAnimationNode(_this, step, context);
+ furthestTime = Math.max(furthestTime, context.currentTime);
+ return innerAst;
+ });
+ context.currentTime = furthestTime;
+ var /** @type {?} */ ast = new GroupAst(steps);
+ ast.options = normalizeAnimationOptions(metadata.options);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitAnimate = function (metadata, context) {
+ var /** @type {?} */ timingAst = constructTimingAst(metadata.timings, context.errors);
+ context.currentAnimateTimings = timingAst;
+ var /** @type {?} */ styles;
+ var /** @type {?} */ styleMetadata = metadata.styles ? metadata.styles : __WEBPACK_IMPORTED_MODULE_1__angular_animations__["style"]({});
+ if (styleMetadata.type == 5 /* Keyframes */) {
+ styles = this.visitKeyframes(/** @type {?} */ (styleMetadata), context);
+ }
+ else {
+ var /** @type {?} */ styleMetadata_1 = (metadata.styles);
+ var /** @type {?} */ isEmpty = false;
+ if (!styleMetadata_1) {
+ isEmpty = true;
+ var /** @type {?} */ newStyleData = {};
+ if (timingAst.easing) {
+ newStyleData['easing'] = timingAst.easing;
+ }
+ styleMetadata_1 = __WEBPACK_IMPORTED_MODULE_1__angular_animations__["style"](newStyleData);
+ }
+ context.currentTime += timingAst.duration + timingAst.delay;
+ var /** @type {?} */ styleAst = this.visitStyle(styleMetadata_1, context);
+ styleAst.isEmptyStep = isEmpty;
+ styles = styleAst;
+ }
+ context.currentAnimateTimings = null;
+ return new AnimateAst(timingAst, styles);
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitStyle = function (metadata, context) {
+ var /** @type {?} */ ast = this._makeStyleAst(metadata, context);
+ this._validateStyleAst(ast, context);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype._makeStyleAst = function (metadata, context) {
+ var /** @type {?} */ styles = [];
+ if (Array.isArray(metadata.styles)) {
+ ((metadata.styles)).forEach(function (styleTuple) {
+ if (typeof styleTuple == 'string') {
+ if (styleTuple == __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"]) {
+ styles.push(/** @type {?} */ (styleTuple));
+ }
+ else {
+ context.errors.push("The provided style string value " + styleTuple + " is not allowed.");
+ }
+ }
+ else {
+ styles.push(/** @type {?} */ (styleTuple));
+ }
+ });
+ }
+ else {
+ styles.push(metadata.styles);
+ }
+ var /** @type {?} */ collectedEasing = null;
+ styles.forEach(function (styleData) {
+ if (isObject(styleData)) {
+ var /** @type {?} */ styleMap = (styleData);
+ var /** @type {?} */ easing = styleMap['easing'];
+ if (easing) {
+ collectedEasing = (easing);
+ delete styleMap['easing'];
+ }
+ }
+ });
+ return new StyleAst(styles, collectedEasing, metadata.offset);
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype._validateStyleAst = function (ast, context) {
+ var /** @type {?} */ timings = context.currentAnimateTimings;
+ var /** @type {?} */ endTime = context.currentTime;
+ var /** @type {?} */ startTime = context.currentTime;
+ if (timings && startTime > 0) {
+ startTime -= timings.duration + timings.delay;
+ }
+ ast.styles.forEach(function (tuple) {
+ if (typeof tuple == 'string')
+ return;
+ Object.keys(tuple).forEach(function (prop) {
+ var /** @type {?} */ collectedStyles = context.collectedStyles[((context.currentQuerySelector))];
+ var /** @type {?} */ collectedEntry = collectedStyles[prop];
+ var /** @type {?} */ updateCollectedStyle = true;
+ if (collectedEntry) {
+ if (startTime != endTime && startTime >= collectedEntry.startTime &&
+ endTime <= collectedEntry.endTime) {
+ context.errors.push("The CSS property \"" + prop + "\" that exists between the times of \"" + collectedEntry.startTime + "ms\" and \"" + collectedEntry.endTime + "ms\" is also being animated in a parallel animation between the times of \"" + startTime + "ms\" and \"" + endTime + "ms\"");
+ updateCollectedStyle = false;
+ }
+ // we always choose the smaller start time value since we
+ // want to have a record of the entire animation window where
+ // the style property is being animated in between
+ startTime = collectedEntry.startTime;
+ }
+ if (updateCollectedStyle) {
+ collectedStyles[prop] = { startTime: startTime, endTime: endTime };
+ }
+ if (context.options) {
+ validateStyleParams(tuple[prop], context.options, context.errors);
+ }
+ });
+ });
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitKeyframes = function (metadata, context) {
+ var _this = this;
+ if (!context.currentAnimateTimings) {
+ context.errors.push("keyframes() must be placed inside of a call to animate()");
+ return new KeyframesAst([]);
+ }
+ var /** @type {?} */ MAX_KEYFRAME_OFFSET = 1;
+ var /** @type {?} */ totalKeyframesWithOffsets = 0;
+ var /** @type {?} */ offsets = [];
+ var /** @type {?} */ offsetsOutOfOrder = false;
+ var /** @type {?} */ keyframesOutOfRange = false;
+ var /** @type {?} */ previousOffset = 0;
+ var /** @type {?} */ keyframes = metadata.steps.map(function (styles) {
+ var /** @type {?} */ style$$1 = _this._makeStyleAst(styles, context);
+ var /** @type {?} */ offsetVal = style$$1.offset != null ? style$$1.offset : consumeOffset(style$$1.styles);
+ var /** @type {?} */ offset = 0;
+ if (offsetVal != null) {
+ totalKeyframesWithOffsets++;
+ offset = style$$1.offset = offsetVal;
+ }
+ keyframesOutOfRange = keyframesOutOfRange || offset < 0 || offset > 1;
+ offsetsOutOfOrder = offsetsOutOfOrder || offset < previousOffset;
+ previousOffset = offset;
+ offsets.push(offset);
+ return style$$1;
+ });
+ if (keyframesOutOfRange) {
+ context.errors.push("Please ensure that all keyframe offsets are between 0 and 1");
+ }
+ if (offsetsOutOfOrder) {
+ context.errors.push("Please ensure that all keyframe offsets are in order");
+ }
+ var /** @type {?} */ length = metadata.steps.length;
+ var /** @type {?} */ generatedOffset = 0;
+ if (totalKeyframesWithOffsets > 0 && totalKeyframesWithOffsets < length) {
+ context.errors.push("Not all style() steps within the declared keyframes() contain offsets");
+ }
+ else if (totalKeyframesWithOffsets == 0) {
+ generatedOffset = MAX_KEYFRAME_OFFSET / (length - 1);
+ }
+ var /** @type {?} */ limit = length - 1;
+ var /** @type {?} */ currentTime = context.currentTime;
+ var /** @type {?} */ currentAnimateTimings = ((context.currentAnimateTimings));
+ var /** @type {?} */ animateDuration = currentAnimateTimings.duration;
+ keyframes.forEach(function (kf, i) {
+ var /** @type {?} */ offset = generatedOffset > 0 ? (i == limit ? 1 : (generatedOffset * i)) : offsets[i];
+ var /** @type {?} */ durationUpToThisFrame = offset * animateDuration;
+ context.currentTime = currentTime + currentAnimateTimings.delay + durationUpToThisFrame;
+ currentAnimateTimings.duration = durationUpToThisFrame;
+ _this._validateStyleAst(kf, context);
+ kf.offset = offset;
+ });
+ return new KeyframesAst(keyframes);
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitReference = function (metadata, context) {
+ var /** @type {?} */ entry = visitAnimationNode(this, normalizeAnimationEntry(metadata.animation), context);
+ var /** @type {?} */ ast = new ReferenceAst(entry);
+ ast.options = normalizeAnimationOptions(metadata.options);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitAnimateChild = function (metadata, context) {
+ context.depCount++;
+ var /** @type {?} */ ast = new AnimateChildAst();
+ ast.options = normalizeAnimationOptions(metadata.options);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitAnimateRef = function (metadata, context) {
+ var /** @type {?} */ animation = this.visitReference(metadata.animation, context);
+ var /** @type {?} */ ast = new AnimateRefAst(animation);
+ ast.options = normalizeAnimationOptions(metadata.options);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitQuery = function (metadata, context) {
+ var /** @type {?} */ parentSelector = ((context.currentQuerySelector));
+ var /** @type {?} */ options = ((metadata.options || {}));
+ context.queryCount++;
+ context.currentQuery = metadata;
+ var _a = normalizeSelector(metadata.selector), selector = _a[0], includeSelf = _a[1];
+ context.currentQuerySelector =
+ parentSelector.length ? (parentSelector + ' ' + selector) : selector;
+ getOrSetAsInMap(context.collectedStyles, context.currentQuerySelector, {});
+ var /** @type {?} */ entry = visitAnimationNode(this, normalizeAnimationEntry(metadata.animation), context);
+ context.currentQuery = null;
+ context.currentQuerySelector = parentSelector;
+ var /** @type {?} */ ast = new QueryAst(selector, options.limit || 0, !!options.optional, includeSelf, entry);
+ ast.originalSelector = metadata.selector;
+ ast.options = normalizeAnimationOptions(metadata.options);
+ return ast;
+ };
+ /**
+ * @param {?} metadata
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationAstBuilderVisitor.prototype.visitStagger = function (metadata, context) {
+ if (!context.currentQuery) {
+ context.errors.push("stagger() can only be used inside of query()");
+ }
+ var /** @type {?} */ timings = metadata.timings === 'full' ?
+ { duration: 0, delay: 0, easing: 'full' } :
+ resolveTiming(metadata.timings, context.errors, true);
+ var /** @type {?} */ animation = visitAnimationNode(this, normalizeAnimationEntry(metadata.animation), context);
+ return new StaggerAst(timings, animation);
+ };
+ return AnimationAstBuilderVisitor;
+}());
+/**
+ * @param {?} selector
+ * @return {?}
+ */
+function normalizeSelector(selector) {
+ var /** @type {?} */ hasAmpersand = selector.split(/\s*,\s*/).find(function (token) { return token == SELF_TOKEN; }) ? true : false;
+ if (hasAmpersand) {
+ selector = selector.replace(SELF_TOKEN_REGEX, '');
+ }
+ selector = selector.replace(ENTER_TOKEN_REGEX, ENTER_SELECTOR)
+ .replace(LEAVE_TOKEN_REGEX, LEAVE_SELECTOR)
+ .replace(/@\*/g, NG_TRIGGER_SELECTOR)
+ .replace(/@\w+/g, function (match) { return NG_TRIGGER_SELECTOR + '-' + match.substr(1); })
+ .replace(/:animating/g, NG_ANIMATING_SELECTOR);
+ return [selector, hasAmpersand];
+}
+/**
+ * @param {?} obj
+ * @return {?}
+ */
+function normalizeParams(obj) {
+ return obj ? copyObj(obj) : null;
+}
+var AnimationAstBuilderContext = (function () {
+ /**
+ * @param {?} errors
+ */
+ function AnimationAstBuilderContext(errors) {
+ this.errors = errors;
+ this.queryCount = 0;
+ this.depCount = 0;
+ this.currentTransition = null;
+ this.currentQuery = null;
+ this.currentQuerySelector = null;
+ this.currentAnimateTimings = null;
+ this.currentTime = 0;
+ this.collectedStyles = {};
+ this.options = null;
+ }
+ return AnimationAstBuilderContext;
+}());
+/**
+ * @param {?} styles
+ * @return {?}
+ */
+function consumeOffset(styles) {
+ if (typeof styles == 'string')
+ return null;
+ var /** @type {?} */ offset = null;
+ if (Array.isArray(styles)) {
+ styles.forEach(function (styleTuple) {
+ if (isObject(styleTuple) && styleTuple.hasOwnProperty('offset')) {
+ var /** @type {?} */ obj = (styleTuple);
+ offset = parseFloat(/** @type {?} */ (obj['offset']));
+ delete obj['offset'];
+ }
+ });
+ }
+ else if (isObject(styles) && styles.hasOwnProperty('offset')) {
+ var /** @type {?} */ obj = (styles);
+ offset = parseFloat(/** @type {?} */ (obj['offset']));
+ delete obj['offset'];
+ }
+ return offset;
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function isObject(value) {
+ return !Array.isArray(value) && typeof value == 'object';
+}
+/**
+ * @param {?} value
+ * @param {?} errors
+ * @return {?}
+ */
+function constructTimingAst(value, errors) {
+ var /** @type {?} */ timings = null;
+ if (value.hasOwnProperty('duration')) {
+ timings = (value);
+ }
+ else if (typeof value == 'number') {
+ var /** @type {?} */ duration = resolveTiming(/** @type {?} */ (value), errors).duration;
+ return new TimingAst(/** @type {?} */ (value), 0, '');
+ }
+ var /** @type {?} */ strValue = (value);
+ var /** @type {?} */ isDynamic = strValue.split(/\s+/).some(function (v) { return v.charAt(0) == '{' && v.charAt(1) == '{'; });
+ if (isDynamic) {
+ return new DynamicTimingAst(strValue);
+ }
+ timings = timings || resolveTiming(strValue, errors);
+ return new TimingAst(timings.duration, timings.delay, timings.easing);
+}
+/**
+ * @param {?} options
+ * @return {?}
+ */
+function normalizeAnimationOptions(options) {
+ if (options) {
+ options = copyObj(options);
+ if (options['params']) {
+ options['params'] = ((normalizeParams(options['params'])));
+ }
+ }
+ else {
+ options = {};
+ }
+ return options;
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @param {?} element
+ * @param {?} keyframes
+ * @param {?} preStyleProps
+ * @param {?} postStyleProps
+ * @param {?} duration
+ * @param {?} delay
+ * @param {?=} easing
+ * @param {?=} subTimeline
+ * @return {?}
+ */
+function createTimelineInstruction(element, keyframes, preStyleProps, postStyleProps, duration, delay, easing, subTimeline) {
+ if (easing === void 0) { easing = null; }
+ if (subTimeline === void 0) { subTimeline = false; }
+ return {
+ type: 1 /* TimelineAnimation */,
+ element: element,
+ keyframes: keyframes,
+ preStyleProps: preStyleProps,
+ postStyleProps: postStyleProps,
+ duration: duration,
+ delay: delay,
+ totalTime: duration + delay, easing: easing, subTimeline: subTimeline
+ };
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var ElementInstructionMap = (function () {
+ function ElementInstructionMap() {
+ this._map = new Map();
+ }
+ /**
+ * @param {?} element
+ * @return {?}
+ */
+ ElementInstructionMap.prototype.consume = function (element) {
+ var /** @type {?} */ instructions = this._map.get(element);
+ if (instructions) {
+ this._map.delete(element);
+ }
+ else {
+ instructions = [];
+ }
+ return instructions;
+ };
+ /**
+ * @param {?} element
+ * @param {?} instructions
+ * @return {?}
+ */
+ ElementInstructionMap.prototype.append = function (element, instructions) {
+ var /** @type {?} */ existingInstructions = this._map.get(element);
+ if (!existingInstructions) {
+ this._map.set(element, existingInstructions = []);
+ }
+ existingInstructions.push.apply(existingInstructions, instructions);
+ };
+ /**
+ * @param {?} element
+ * @return {?}
+ */
+ ElementInstructionMap.prototype.has = function (element) { return this._map.has(element); };
+ /**
+ * @return {?}
+ */
+ ElementInstructionMap.prototype.clear = function () { this._map.clear(); };
+ return ElementInstructionMap;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var ONE_FRAME_IN_MILLISECONDS = 1;
+/**
+ * @param {?} driver
+ * @param {?} rootElement
+ * @param {?} ast
+ * @param {?=} startingStyles
+ * @param {?=} finalStyles
+ * @param {?=} options
+ * @param {?=} subInstructions
+ * @param {?=} errors
+ * @return {?}
+ */
+function buildAnimationTimelines(driver, rootElement, ast, startingStyles, finalStyles, options, subInstructions, errors) {
+ if (startingStyles === void 0) { startingStyles = {}; }
+ if (finalStyles === void 0) { finalStyles = {}; }
+ if (errors === void 0) { errors = []; }
+ return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, startingStyles, finalStyles, options, subInstructions, errors);
+}
+var AnimationTimelineBuilderVisitor = (function () {
+ function AnimationTimelineBuilderVisitor() {
+ }
+ /**
+ * @param {?} driver
+ * @param {?} rootElement
+ * @param {?} ast
+ * @param {?} startingStyles
+ * @param {?} finalStyles
+ * @param {?} options
+ * @param {?=} subInstructions
+ * @param {?=} errors
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.buildKeyframes = function (driver, rootElement, ast, startingStyles, finalStyles, options, subInstructions, errors) {
+ if (errors === void 0) { errors = []; }
+ subInstructions = subInstructions || new ElementInstructionMap();
+ var /** @type {?} */ context = new AnimationTimelineContext(driver, rootElement, subInstructions, errors, []);
+ context.options = options;
+ context.currentTimeline.setStyles([startingStyles], null, context.errors, options);
+ ast.visit(this, context);
+ // this checks to see if an actual animation happened
+ var /** @type {?} */ timelines = context.timelines.filter(function (timeline) { return timeline.containsAnimation(); });
+ if (timelines.length && Object.keys(finalStyles).length) {
+ var /** @type {?} */ tl = timelines[timelines.length - 1];
+ if (!tl.allowOnlyTimelineStyles()) {
+ tl.setStyles([finalStyles], null, context.errors, options);
+ }
+ }
+ return timelines.length ? timelines.map(function (timeline) { return timeline.buildKeyframes(); }) :
+ [createTimelineInstruction(rootElement, [], [], [], 0, 0, '', false)];
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitTrigger = function (ast, context) {
+ // these values are not visited in this AST
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitState = function (ast, context) {
+ // these values are not visited in this AST
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitTransition = function (ast, context) {
+ // these values are not visited in this AST
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitAnimateChild = function (ast, context) {
+ var /** @type {?} */ elementInstructions = context.subInstructions.consume(context.element);
+ if (elementInstructions) {
+ var /** @type {?} */ innerContext = context.createSubContext(ast.options);
+ var /** @type {?} */ startTime = context.currentTimeline.currentTime;
+ var /** @type {?} */ endTime = this._visitSubInstructions(elementInstructions, innerContext, /** @type {?} */ (innerContext.options));
+ if (startTime != endTime) {
+ // we do this on the upper context because we created a sub context for
+ // the sub child animations
+ context.transformIntoNewTimeline(endTime);
+ }
+ }
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitAnimateRef = function (ast, context) {
+ var /** @type {?} */ innerContext = context.createSubContext(ast.options);
+ innerContext.transformIntoNewTimeline();
+ this.visitReference(ast.animation, innerContext);
+ context.transformIntoNewTimeline(innerContext.currentTimeline.currentTime);
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} instructions
+ * @param {?} context
+ * @param {?} options
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype._visitSubInstructions = function (instructions, context, options) {
+ var /** @type {?} */ startTime = context.currentTimeline.currentTime;
+ var /** @type {?} */ furthestTime = startTime;
+ // this is a special-case for when a user wants to skip a sub
+ // animation from being fired entirely.
+ var /** @type {?} */ duration = options.duration != null ? resolveTimingValue(options.duration) : null;
+ var /** @type {?} */ delay = options.delay != null ? resolveTimingValue(options.delay) : null;
+ if (duration !== 0) {
+ instructions.forEach(function (instruction) {
+ var /** @type {?} */ instructionTimings = context.appendInstructionToTimeline(instruction, duration, delay);
+ furthestTime =
+ Math.max(furthestTime, instructionTimings.duration + instructionTimings.delay);
+ });
+ }
+ return furthestTime;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitReference = function (ast, context) {
+ context.updateOptions(ast.options, true);
+ ast.animation.visit(this, context);
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitSequence = function (ast, context) {
+ var _this = this;
+ var /** @type {?} */ subContextCount = context.subContextCount;
+ var /** @type {?} */ ctx = context;
+ var /** @type {?} */ options = ast.options;
+ if (options && (options.params || options.delay)) {
+ ctx = context.createSubContext(options);
+ ctx.transformIntoNewTimeline();
+ if (options.delay != null) {
+ if (ctx.previousNode instanceof StyleAst) {
+ ctx.currentTimeline.snapshotCurrentStyles();
+ ctx.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ }
+ var /** @type {?} */ delay = resolveTimingValue(options.delay);
+ ctx.delayNextStep(delay);
+ }
+ }
+ if (ast.steps.length) {
+ ast.steps.forEach(function (s) { return s.visit(_this, ctx); });
+ // this is here just incase the inner steps only contain or end with a style() call
+ ctx.currentTimeline.applyStylesToKeyframe();
+ // this means that some animation function within the sequence
+ // ended up creating a sub timeline (which means the current
+ // timeline cannot overlap with the contents of the sequence)
+ if (ctx.subContextCount > subContextCount) {
+ ctx.transformIntoNewTimeline();
+ }
+ }
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitGroup = function (ast, context) {
+ var _this = this;
+ var /** @type {?} */ innerTimelines = [];
+ var /** @type {?} */ furthestTime = context.currentTimeline.currentTime;
+ var /** @type {?} */ delay = ast.options && ast.options.delay ? resolveTimingValue(ast.options.delay) : 0;
+ ast.steps.forEach(function (s) {
+ var /** @type {?} */ innerContext = context.createSubContext(ast.options);
+ if (delay) {
+ innerContext.delayNextStep(delay);
+ }
+ s.visit(_this, innerContext);
+ furthestTime = Math.max(furthestTime, innerContext.currentTimeline.currentTime);
+ innerTimelines.push(innerContext.currentTimeline);
+ });
+ // this operation is run after the AST loop because otherwise
+ // if the parent timeline's collected styles were updated then
+ // it would pass in invalid data into the new-to-be forked items
+ innerTimelines.forEach(function (timeline) { return context.currentTimeline.mergeTimelineCollectedStyles(timeline); });
+ context.transformIntoNewTimeline(furthestTime);
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitTiming = function (ast, context) {
+ if (ast instanceof DynamicTimingAst) {
+ var /** @type {?} */ strValue = context.params ?
+ interpolateParams(ast.value, context.params, context.errors) :
+ ast.value.toString();
+ return resolveTiming(strValue, context.errors);
+ }
+ else {
+ return { duration: ast.duration, delay: ast.delay, easing: ast.easing };
+ }
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitAnimate = function (ast, context) {
+ var /** @type {?} */ timings = context.currentAnimateTimings = this.visitTiming(ast.timings, context);
+ var /** @type {?} */ timeline = context.currentTimeline;
+ if (timings.delay) {
+ context.incrementTime(timings.delay);
+ timeline.snapshotCurrentStyles();
+ }
+ var /** @type {?} */ style$$1 = ast.style;
+ if (style$$1 instanceof KeyframesAst) {
+ this.visitKeyframes(style$$1, context);
+ }
+ else {
+ context.incrementTime(timings.duration);
+ this.visitStyle(/** @type {?} */ (style$$1), context);
+ timeline.applyStylesToKeyframe();
+ }
+ context.currentAnimateTimings = null;
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitStyle = function (ast, context) {
+ var /** @type {?} */ timeline = context.currentTimeline;
+ var /** @type {?} */ timings = ((context.currentAnimateTimings));
+ // this is a special case for when a style() call
+ // directly follows an animate() call (but not inside of an animate() call)
+ if (!timings && timeline.getCurrentStyleProperties().length) {
+ timeline.forwardFrame();
+ }
+ var /** @type {?} */ easing = (timings && timings.easing) || ast.easing;
+ if (ast.isEmptyStep) {
+ timeline.applyEmptyStep(easing);
+ }
+ else {
+ timeline.setStyles(ast.styles, easing, context.errors, context.options);
+ }
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitKeyframes = function (ast, context) {
+ var /** @type {?} */ currentAnimateTimings = ((context.currentAnimateTimings));
+ var /** @type {?} */ startTime = (((context.currentTimeline))).duration;
+ var /** @type {?} */ duration = currentAnimateTimings.duration;
+ var /** @type {?} */ innerContext = context.createSubContext();
+ var /** @type {?} */ innerTimeline = innerContext.currentTimeline;
+ innerTimeline.easing = currentAnimateTimings.easing;
+ ast.styles.forEach(function (step) {
+ var /** @type {?} */ offset = step.offset || 0;
+ innerTimeline.forwardTime(offset * duration);
+ innerTimeline.setStyles(step.styles, step.easing, context.errors, context.options);
+ innerTimeline.applyStylesToKeyframe();
+ });
+ // this will ensure that the parent timeline gets all the styles from
+ // the child even if the new timeline below is not used
+ context.currentTimeline.mergeTimelineCollectedStyles(innerTimeline);
+ // we do this because the window between this timeline and the sub timeline
+ // should ensure that the styles within are exactly the same as they were before
+ context.transformIntoNewTimeline(startTime + duration);
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitQuery = function (ast, context) {
+ var _this = this;
+ // in the event that the first step before this is a style step we need
+ // to ensure the styles are applied before the children are animated
+ var /** @type {?} */ startTime = context.currentTimeline.currentTime;
+ var /** @type {?} */ options = ((ast.options || {}));
+ var /** @type {?} */ delay = options.delay ? resolveTimingValue(options.delay) : 0;
+ if (delay && (context.previousNode instanceof StyleAst ||
+ (startTime == 0 && context.currentTimeline.getCurrentStyleProperties().length))) {
+ context.currentTimeline.snapshotCurrentStyles();
+ context.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ }
+ var /** @type {?} */ furthestTime = startTime;
+ var /** @type {?} */ elms = context.invokeQuery(ast.selector, ast.originalSelector, ast.limit, ast.includeSelf, options.optional ? true : false, context.errors);
+ context.currentQueryTotal = elms.length;
+ var /** @type {?} */ sameElementTimeline = null;
+ elms.forEach(function (element, i) {
+ context.currentQueryIndex = i;
+ var /** @type {?} */ innerContext = context.createSubContext(ast.options, element);
+ if (delay) {
+ innerContext.delayNextStep(delay);
+ }
+ if (element === context.element) {
+ sameElementTimeline = innerContext.currentTimeline;
+ }
+ ast.animation.visit(_this, innerContext);
+ // this is here just incase the inner steps only contain or end
+ // with a style() call (which is here to signal that this is a preparatory
+ // call to style an element before it is animated again)
+ innerContext.currentTimeline.applyStylesToKeyframe();
+ var /** @type {?} */ endTime = innerContext.currentTimeline.currentTime;
+ furthestTime = Math.max(furthestTime, endTime);
+ });
+ context.currentQueryIndex = 0;
+ context.currentQueryTotal = 0;
+ context.transformIntoNewTimeline(furthestTime);
+ if (sameElementTimeline) {
+ context.currentTimeline.mergeTimelineCollectedStyles(sameElementTimeline);
+ context.currentTimeline.snapshotCurrentStyles();
+ }
+ context.previousNode = ast;
+ };
+ /**
+ * @param {?} ast
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTimelineBuilderVisitor.prototype.visitStagger = function (ast, context) {
+ var /** @type {?} */ parentContext = ((context.parentContext));
+ var /** @type {?} */ tl = context.currentTimeline;
+ var /** @type {?} */ timings = ast.timings;
+ var /** @type {?} */ duration = Math.abs(timings.duration);
+ var /** @type {?} */ maxTime = duration * (context.currentQueryTotal - 1);
+ var /** @type {?} */ delay = duration * context.currentQueryIndex;
+ var /** @type {?} */ staggerTransformer = timings.duration < 0 ? 'reverse' : timings.easing;
+ switch (staggerTransformer) {
+ case 'reverse':
+ delay = maxTime - delay;
+ break;
+ case 'full':
+ delay = parentContext.currentStaggerTime;
+ break;
+ }
+ var /** @type {?} */ timeline = context.currentTimeline;
+ if (delay) {
+ timeline.delayNextStep(delay);
+ }
+ var /** @type {?} */ startingTime = timeline.currentTime;
+ ast.animation.visit(this, context);
+ context.previousNode = ast;
+ // time = duration + delay
+ // the reason why this computation is so complex is because
+ // the inner timeline may either have a delay value or a stretched
+ // keyframe depending on if a subtimeline is not used or is used.
+ parentContext.currentStaggerTime =
+ (tl.currentTime - startingTime) + (tl.startTime - parentContext.currentTimeline.startTime);
+ };
+ return AnimationTimelineBuilderVisitor;
+}());
+var DEFAULT_NOOP_PREVIOUS_NODE = ({});
+var AnimationTimelineContext = (function () {
+ /**
+ * @param {?} _driver
+ * @param {?} element
+ * @param {?} subInstructions
+ * @param {?} errors
+ * @param {?} timelines
+ * @param {?=} initialTimeline
+ */
+ function AnimationTimelineContext(_driver, element, subInstructions, errors, timelines, initialTimeline) {
+ this._driver = _driver;
+ this.element = element;
+ this.subInstructions = subInstructions;
+ this.errors = errors;
+ this.timelines = timelines;
+ this.parentContext = null;
+ this.currentAnimateTimings = null;
+ this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ this.subContextCount = 0;
+ this.options = {};
+ this.currentQueryIndex = 0;
+ this.currentQueryTotal = 0;
+ this.currentStaggerTime = 0;
+ this.currentTimeline = initialTimeline || new TimelineBuilder(element, 0);
+ timelines.push(this.currentTimeline);
+ }
+ Object.defineProperty(AnimationTimelineContext.prototype, "params", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this.options.params; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} options
+ * @param {?=} skipIfExists
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.updateOptions = function (options, skipIfExists) {
+ var _this = this;
+ if (!options)
+ return;
+ var /** @type {?} */ newOptions = (options);
+ var /** @type {?} */ optionsToUpdate = this.options;
+ // NOTE: this will get patched up when other animation methods support duration overrides
+ if (newOptions.duration != null) {
+ ((optionsToUpdate)).duration = resolveTimingValue(newOptions.duration);
+ }
+ if (newOptions.delay != null) {
+ optionsToUpdate.delay = resolveTimingValue(newOptions.delay);
+ }
+ var /** @type {?} */ newParams = newOptions.params;
+ if (newParams) {
+ var /** @type {?} */ paramsToUpdate_1 = ((optionsToUpdate.params));
+ if (!paramsToUpdate_1) {
+ paramsToUpdate_1 = this.options.params = {};
+ }
+ Object.keys(newParams).forEach(function (name) {
+ if (!skipIfExists || !paramsToUpdate_1.hasOwnProperty(name)) {
+ paramsToUpdate_1[name] = interpolateParams(newParams[name], paramsToUpdate_1, _this.errors);
+ }
+ });
+ }
+ };
+ /**
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype._copyOptions = function () {
+ var /** @type {?} */ options = {};
+ if (this.options) {
+ var /** @type {?} */ oldParams_1 = this.options.params;
+ if (oldParams_1) {
+ var /** @type {?} */ params_1 = options['params'] = {};
+ Object.keys(this.options.params).forEach(function (name) { params_1[name] = oldParams_1[name]; });
+ }
+ }
+ return options;
+ };
+ /**
+ * @param {?=} options
+ * @param {?=} element
+ * @param {?=} newTime
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.createSubContext = function (options, element, newTime) {
+ if (options === void 0) { options = null; }
+ var /** @type {?} */ target = element || this.element;
+ var /** @type {?} */ context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0));
+ context.previousNode = this.previousNode;
+ context.currentAnimateTimings = this.currentAnimateTimings;
+ context.options = this._copyOptions();
+ context.updateOptions(options);
+ context.currentQueryIndex = this.currentQueryIndex;
+ context.currentQueryTotal = this.currentQueryTotal;
+ context.parentContext = this;
+ this.subContextCount++;
+ return context;
+ };
+ /**
+ * @param {?=} newTime
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.transformIntoNewTimeline = function (newTime) {
+ this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE;
+ this.currentTimeline = this.currentTimeline.fork(this.element, newTime);
+ this.timelines.push(this.currentTimeline);
+ return this.currentTimeline;
+ };
+ /**
+ * @param {?} instruction
+ * @param {?} duration
+ * @param {?} delay
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.appendInstructionToTimeline = function (instruction, duration, delay) {
+ var /** @type {?} */ updatedTimings = {
+ duration: duration != null ? duration : instruction.duration,
+ delay: this.currentTimeline.currentTime + (delay != null ? delay : 0) + instruction.delay,
+ easing: ''
+ };
+ var /** @type {?} */ builder = new SubTimelineBuilder(instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe);
+ this.timelines.push(builder);
+ return updatedTimings;
+ };
+ /**
+ * @param {?} time
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.incrementTime = function (time) {
+ this.currentTimeline.forwardTime(this.currentTimeline.duration + time);
+ };
+ /**
+ * @param {?} delay
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.delayNextStep = function (delay) {
+ // negative delays are not yet supported
+ if (delay > 0) {
+ this.currentTimeline.delayNextStep(delay);
+ }
+ };
+ /**
+ * @param {?} selector
+ * @param {?} originalSelector
+ * @param {?} limit
+ * @param {?} includeSelf
+ * @param {?} optional
+ * @param {?} errors
+ * @return {?}
+ */
+ AnimationTimelineContext.prototype.invokeQuery = function (selector, originalSelector, limit, includeSelf, optional, errors) {
+ var /** @type {?} */ results = [];
+ if (includeSelf) {
+ results.push(this.element);
+ }
+ if (selector.length > 0) {
+ var /** @type {?} */ multi = limit != 1;
+ results.push.apply(results, this._driver.query(this.element, selector, multi));
+ }
+ if (!optional && results.length == 0) {
+ errors.push("`query(\"" + originalSelector + "\")` returned zero elements. (Use `query(\"" + originalSelector + "\", { optional: true })` if you wish to allow this.)");
+ }
+ return results;
+ };
+ return AnimationTimelineContext;
+}());
+var TimelineBuilder = (function () {
+ /**
+ * @param {?} element
+ * @param {?} startTime
+ * @param {?=} _elementTimelineStylesLookup
+ */
+ function TimelineBuilder(element, startTime, _elementTimelineStylesLookup) {
+ this.element = element;
+ this.startTime = startTime;
+ this._elementTimelineStylesLookup = _elementTimelineStylesLookup;
+ this.duration = 0;
+ this._previousKeyframe = {};
+ this._currentKeyframe = {};
+ this._keyframes = new Map();
+ this._styleSummary = {};
+ this._pendingStyles = {};
+ this._backFill = {};
+ this._currentEmptyStepKeyframe = null;
+ if (!this._elementTimelineStylesLookup) {
+ this._elementTimelineStylesLookup = new Map();
+ }
+ this._localTimelineStyles = Object.create(this._backFill, {});
+ this._globalTimelineStyles = this._elementTimelineStylesLookup.get(element);
+ if (!this._globalTimelineStyles) {
+ this._globalTimelineStyles = this._localTimelineStyles;
+ this._elementTimelineStylesLookup.set(element, this._localTimelineStyles);
+ }
+ this._loadKeyframe();
+ }
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.containsAnimation = function () {
+ switch (this._keyframes.size) {
+ case 0:
+ return false;
+ case 1:
+ return this.getCurrentStyleProperties().length > 0;
+ default:
+ return true;
+ }
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.getCurrentStyleProperties = function () { return Object.keys(this._currentKeyframe); };
+ Object.defineProperty(TimelineBuilder.prototype, "currentTime", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this.startTime + this.duration; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} delay
+ * @return {?}
+ */
+ TimelineBuilder.prototype.delayNextStep = function (delay) {
+ // in the event that a style() step is placed right before a stagger()
+ // and that style() step is the very first style() value in the animation
+ // then we need to make a copy of the keyframe [0, copy, 1] so that the delay
+ // properly applies the style() values to work with the stagger...
+ var /** @type {?} */ hasPreStyleStep = this._keyframes.size == 1 && Object.keys(this._pendingStyles).length;
+ if (this.duration || hasPreStyleStep) {
+ this.forwardTime(this.currentTime + delay);
+ if (hasPreStyleStep) {
+ this.snapshotCurrentStyles();
+ }
+ }
+ else {
+ this.startTime += delay;
+ }
+ };
+ /**
+ * @param {?} element
+ * @param {?=} currentTime
+ * @return {?}
+ */
+ TimelineBuilder.prototype.fork = function (element, currentTime) {
+ this.applyStylesToKeyframe();
+ return new TimelineBuilder(element, currentTime || this.currentTime, this._elementTimelineStylesLookup);
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype._loadKeyframe = function () {
+ if (this._currentKeyframe) {
+ this._previousKeyframe = this._currentKeyframe;
+ }
+ this._currentKeyframe = ((this._keyframes.get(this.duration)));
+ if (!this._currentKeyframe) {
+ this._currentKeyframe = Object.create(this._backFill, {});
+ this._keyframes.set(this.duration, this._currentKeyframe);
+ }
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.forwardFrame = function () {
+ this.duration += ONE_FRAME_IN_MILLISECONDS;
+ this._loadKeyframe();
+ };
+ /**
+ * @param {?} time
+ * @return {?}
+ */
+ TimelineBuilder.prototype.forwardTime = function (time) {
+ this.applyStylesToKeyframe();
+ this.duration = time;
+ this._loadKeyframe();
+ };
+ /**
+ * @param {?} prop
+ * @param {?} value
+ * @return {?}
+ */
+ TimelineBuilder.prototype._updateStyle = function (prop, value) {
+ this._localTimelineStyles[prop] = value;
+ this._globalTimelineStyles[prop] = value;
+ this._styleSummary[prop] = { time: this.currentTime, value: value };
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.allowOnlyTimelineStyles = function () { return this._currentEmptyStepKeyframe !== this._currentKeyframe; };
+ /**
+ * @param {?} easing
+ * @return {?}
+ */
+ TimelineBuilder.prototype.applyEmptyStep = function (easing) {
+ var _this = this;
+ if (easing) {
+ this._previousKeyframe['easing'] = easing;
+ }
+ // special case for animate(duration):
+ // all missing styles are filled with a `*` value then
+ // if any destination styles are filled in later on the same
+ // keyframe then they will override the overridden styles
+ // We use `_globalTimelineStyles` here because there may be
+ // styles in previous keyframes that are not present in this timeline
+ Object.keys(this._globalTimelineStyles).forEach(function (prop) {
+ _this._backFill[prop] = _this._globalTimelineStyles[prop] || __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"];
+ _this._currentKeyframe[prop] = __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"];
+ });
+ this._currentEmptyStepKeyframe = this._currentKeyframe;
+ };
+ /**
+ * @param {?} input
+ * @param {?} easing
+ * @param {?} errors
+ * @param {?=} options
+ * @return {?}
+ */
+ TimelineBuilder.prototype.setStyles = function (input, easing, errors, options) {
+ var _this = this;
+ if (easing) {
+ this._previousKeyframe['easing'] = easing;
+ }
+ var /** @type {?} */ params = (options && options.params) || {};
+ var /** @type {?} */ styles = flattenStyles(input, this._globalTimelineStyles);
+ Object.keys(styles).forEach(function (prop) {
+ var /** @type {?} */ val = interpolateParams(styles[prop], params, errors);
+ _this._pendingStyles[prop] = val;
+ if (!_this._localTimelineStyles.hasOwnProperty(prop)) {
+ _this._backFill[prop] = _this._globalTimelineStyles.hasOwnProperty(prop) ?
+ _this._globalTimelineStyles[prop] :
+ __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"];
+ }
+ _this._updateStyle(prop, val);
+ });
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.applyStylesToKeyframe = function () {
+ var _this = this;
+ var /** @type {?} */ styles = this._pendingStyles;
+ var /** @type {?} */ props = Object.keys(styles);
+ if (props.length == 0)
+ return;
+ this._pendingStyles = {};
+ props.forEach(function (prop) {
+ var /** @type {?} */ val = styles[prop];
+ _this._currentKeyframe[prop] = val;
+ });
+ Object.keys(this._localTimelineStyles).forEach(function (prop) {
+ if (!_this._currentKeyframe.hasOwnProperty(prop)) {
+ _this._currentKeyframe[prop] = _this._localTimelineStyles[prop];
+ }
+ });
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.snapshotCurrentStyles = function () {
+ var _this = this;
+ Object.keys(this._localTimelineStyles).forEach(function (prop) {
+ var /** @type {?} */ val = _this._localTimelineStyles[prop];
+ _this._pendingStyles[prop] = val;
+ _this._updateStyle(prop, val);
+ });
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.getFinalKeyframe = function () { return this._keyframes.get(this.duration); };
+ Object.defineProperty(TimelineBuilder.prototype, "properties", {
+ /**
+ * @return {?}
+ */
+ get: function () {
+ var /** @type {?} */ properties = [];
+ for (var /** @type {?} */ prop in this._currentKeyframe) {
+ properties.push(prop);
+ }
+ return properties;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} timeline
+ * @return {?}
+ */
+ TimelineBuilder.prototype.mergeTimelineCollectedStyles = function (timeline) {
+ var _this = this;
+ Object.keys(timeline._styleSummary).forEach(function (prop) {
+ var /** @type {?} */ details0 = _this._styleSummary[prop];
+ var /** @type {?} */ details1 = timeline._styleSummary[prop];
+ if (!details0 || details1.time > details0.time) {
+ _this._updateStyle(prop, details1.value);
+ }
+ });
+ };
+ /**
+ * @return {?}
+ */
+ TimelineBuilder.prototype.buildKeyframes = function () {
+ var _this = this;
+ this.applyStylesToKeyframe();
+ var /** @type {?} */ preStyleProps = new Set();
+ var /** @type {?} */ postStyleProps = new Set();
+ var /** @type {?} */ isEmpty = this._keyframes.size === 1 && this.duration === 0;
+ var /** @type {?} */ finalKeyframes = [];
+ this._keyframes.forEach(function (keyframe, time) {
+ var /** @type {?} */ finalKeyframe = copyStyles(keyframe, true);
+ Object.keys(finalKeyframe).forEach(function (prop) {
+ var /** @type {?} */ value = finalKeyframe[prop];
+ if (value == __WEBPACK_IMPORTED_MODULE_1__angular_animations__["ɵPRE_STYLE"]) {
+ preStyleProps.add(prop);
+ }
+ else if (value == __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"]) {
+ postStyleProps.add(prop);
+ }
+ });
+ if (!isEmpty) {
+ finalKeyframe['offset'] = time / _this.duration;
+ }
+ finalKeyframes.push(finalKeyframe);
+ });
+ var /** @type {?} */ preProps = preStyleProps.size ? iteratorToArray(preStyleProps.values()) : [];
+ var /** @type {?} */ postProps = postStyleProps.size ? iteratorToArray(postStyleProps.values()) : [];
+ // special case for a 0-second animation (which is designed just to place styles onscreen)
+ if (isEmpty) {
+ var /** @type {?} */ kf0 = finalKeyframes[0];
+ var /** @type {?} */ kf1 = copyObj(kf0);
+ kf0['offset'] = 0;
+ kf1['offset'] = 1;
+ finalKeyframes = [kf0, kf1];
+ }
+ return createTimelineInstruction(this.element, finalKeyframes, preProps, postProps, this.duration, this.startTime, this.easing, false);
+ };
+ return TimelineBuilder;
+}());
+var SubTimelineBuilder = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](SubTimelineBuilder, _super);
+ /**
+ * @param {?} element
+ * @param {?} keyframes
+ * @param {?} preStyleProps
+ * @param {?} postStyleProps
+ * @param {?} timings
+ * @param {?=} _stretchStartingKeyframe
+ */
+ function SubTimelineBuilder(element, keyframes, preStyleProps, postStyleProps, timings, _stretchStartingKeyframe) {
+ if (_stretchStartingKeyframe === void 0) { _stretchStartingKeyframe = false; }
+ var _this = _super.call(this, element, timings.delay) || this;
+ _this.element = element;
+ _this.keyframes = keyframes;
+ _this.preStyleProps = preStyleProps;
+ _this.postStyleProps = postStyleProps;
+ _this._stretchStartingKeyframe = _stretchStartingKeyframe;
+ _this.timings = { duration: timings.duration, delay: timings.delay, easing: timings.easing };
+ return _this;
+ }
+ /**
+ * @return {?}
+ */
+ SubTimelineBuilder.prototype.containsAnimation = function () { return this.keyframes.length > 1; };
+ /**
+ * @return {?}
+ */
+ SubTimelineBuilder.prototype.buildKeyframes = function () {
+ var /** @type {?} */ keyframes = this.keyframes;
+ var _a = this.timings, delay = _a.delay, duration = _a.duration, easing = _a.easing;
+ if (this._stretchStartingKeyframe && delay) {
+ var /** @type {?} */ newKeyframes = [];
+ var /** @type {?} */ totalTime = duration + delay;
+ var /** @type {?} */ startingGap = delay / totalTime;
+ // the original starting keyframe now starts once the delay is done
+ var /** @type {?} */ newFirstKeyframe = copyStyles(keyframes[0], false);
+ newFirstKeyframe['offset'] = 0;
+ newKeyframes.push(newFirstKeyframe);
+ var /** @type {?} */ oldFirstKeyframe = copyStyles(keyframes[0], false);
+ oldFirstKeyframe['offset'] = roundOffset(startingGap);
+ newKeyframes.push(oldFirstKeyframe);
+ /*
+ When the keyframe is stretched then it means that the delay before the animation
+ starts is gone. Instead the first keyframe is placed at the start of the animation
+ and it is then copied to where it starts when the original delay is over. This basically
+ means nothing animates during that delay, but the styles are still renderered. For this
+ to work the original offset values that exist in the original keyframes must be "warped"
+ so that they can take the new keyframe + delay into account.
+
+ delay=1000, duration=1000, keyframes = 0 .5 1
+
+ turns into
+
+ delay=0, duration=2000, keyframes = 0 .33 .66 1
+ */
+ // offsets between 1 ... n -1 are all warped by the keyframe stretch
+ var /** @type {?} */ limit = keyframes.length - 1;
+ for (var /** @type {?} */ i = 1; i <= limit; i++) {
+ var /** @type {?} */ kf = copyStyles(keyframes[i], false);
+ var /** @type {?} */ oldOffset = (kf['offset']);
+ var /** @type {?} */ timeAtKeyframe = delay + oldOffset * duration;
+ kf['offset'] = roundOffset(timeAtKeyframe / totalTime);
+ newKeyframes.push(kf);
+ }
+ // the new starting keyframe should be added at the start
+ duration = totalTime;
+ delay = 0;
+ easing = '';
+ keyframes = newKeyframes;
+ }
+ return createTimelineInstruction(this.element, keyframes, this.preStyleProps, this.postStyleProps, duration, delay, easing, true);
+ };
+ return SubTimelineBuilder;
+}(TimelineBuilder));
+/**
+ * @param {?} offset
+ * @param {?=} decimalPoints
+ * @return {?}
+ */
+function roundOffset(offset, decimalPoints) {
+ if (decimalPoints === void 0) { decimalPoints = 3; }
+ var /** @type {?} */ mult = Math.pow(10, decimalPoints - 1);
+ return Math.round(offset * mult) / mult;
+}
+/**
+ * @param {?} input
+ * @param {?} allStyles
+ * @return {?}
+ */
+function flattenStyles(input, allStyles) {
+ var /** @type {?} */ styles = {};
+ var /** @type {?} */ allProperties;
+ input.forEach(function (token) {
+ if (token === '*') {
+ allProperties = allProperties || Object.keys(allStyles);
+ allProperties.forEach(function (prop) { styles[prop] = __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"]; });
+ }
+ else {
+ copyStyles(/** @type {?} */ (token), false, styles);
+ }
+ });
+ return styles;
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var Animation = (function () {
+ /**
+ * @param {?} _driver
+ * @param {?} input
+ */
+ function Animation(_driver, input) {
+ this._driver = _driver;
+ var errors = [];
+ var ast = buildAnimationAst(input, errors);
+ if (errors.length) {
+ var errorMessage = "animation validation failed:\n" + errors.join("\n");
+ throw new Error(errorMessage);
+ }
+ this._animationAst = ast;
+ }
+ /**
+ * @param {?} element
+ * @param {?} startingStyles
+ * @param {?} destinationStyles
+ * @param {?} options
+ * @param {?=} subInstructions
+ * @return {?}
+ */
+ Animation.prototype.buildTimelines = function (element, startingStyles, destinationStyles, options, subInstructions) {
+ var /** @type {?} */ start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) : (startingStyles);
+ var /** @type {?} */ dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) : (destinationStyles);
+ var /** @type {?} */ errors = [];
+ subInstructions = subInstructions || new ElementInstructionMap();
+ var /** @type {?} */ result = buildAnimationTimelines(this._driver, element, this._animationAst, start, dest, options, subInstructions, errors);
+ if (errors.length) {
+ var /** @type {?} */ errorMessage = "animation building failed:\n" + errors.join("\n");
+ throw new Error(errorMessage);
+ }
+ return result;
+ };
+ return Animation;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @experimental Animation support is experimental.
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */ var AnimationStyleNormalizer = (function () {
+ function AnimationStyleNormalizer() {
+ }
+ return AnimationStyleNormalizer;
+}());
+/**
+ * @experimental Animation support is experimental.
+ */
+var NoopAnimationStyleNormalizer = (function () {
+ function NoopAnimationStyleNormalizer() {
+ }
+ NoopAnimationStyleNormalizer.prototype.normalizePropertyName = function (propertyName, errors) { return propertyName; };
+ NoopAnimationStyleNormalizer.prototype.normalizeStyleValue = function (userProvidedProperty, normalizedProperty, value, errors) {
+ return value;
+ };
+ return NoopAnimationStyleNormalizer;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var WebAnimationsStyleNormalizer = (function (_super) {
+ __WEBPACK_IMPORTED_MODULE_0_tslib__["a" /* __extends */](WebAnimationsStyleNormalizer, _super);
+ function WebAnimationsStyleNormalizer() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ /**
+ * @param {?} propertyName
+ * @param {?} errors
+ * @return {?}
+ */
+ WebAnimationsStyleNormalizer.prototype.normalizePropertyName = function (propertyName, errors) {
+ return dashCaseToCamelCase(propertyName);
+ };
+ /**
+ * @param {?} userProvidedProperty
+ * @param {?} normalizedProperty
+ * @param {?} value
+ * @param {?} errors
+ * @return {?}
+ */
+ WebAnimationsStyleNormalizer.prototype.normalizeStyleValue = function (userProvidedProperty, normalizedProperty, value, errors) {
+ var /** @type {?} */ unit = '';
+ var /** @type {?} */ strVal = value.toString().trim();
+ if (DIMENSIONAL_PROP_MAP[normalizedProperty] && value !== 0 && value !== '0') {
+ if (typeof value === 'number') {
+ unit = 'px';
+ }
+ else {
+ var /** @type {?} */ valAndSuffixMatch = value.match(/^[+-]?[\d\.]+([a-z]*)$/);
+ if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {
+ errors.push("Please provide a CSS unit value for " + userProvidedProperty + ":" + value);
+ }
+ }
+ }
+ return strVal + unit;
+ };
+ return WebAnimationsStyleNormalizer;
+}(AnimationStyleNormalizer));
+var DIMENSIONAL_PROP_MAP = makeBooleanMap('width,height,minWidth,minHeight,maxWidth,maxHeight,left,top,bottom,right,fontSize,outlineWidth,outlineOffset,paddingTop,paddingLeft,paddingBottom,paddingRight,marginTop,marginLeft,marginBottom,marginRight,borderRadius,borderWidth,borderTopWidth,borderLeftWidth,borderRightWidth,borderBottomWidth,textIndent,perspective'
+ .split(','));
+/**
+ * @param {?} keys
+ * @return {?}
+ */
+function makeBooleanMap(keys) {
+ var /** @type {?} */ map = {};
+ keys.forEach(function (key) { return map[key] = true; });
+ return map;
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @param {?} element
+ * @param {?} triggerName
+ * @param {?} fromState
+ * @param {?} toState
+ * @param {?} isRemovalTransition
+ * @param {?} fromStyles
+ * @param {?} toStyles
+ * @param {?} timelines
+ * @param {?} queriedElements
+ * @param {?} preStyleProps
+ * @param {?} postStyleProps
+ * @param {?=} errors
+ * @return {?}
+ */
+function createTransitionInstruction(element, triggerName, fromState, toState, isRemovalTransition, fromStyles, toStyles, timelines, queriedElements, preStyleProps, postStyleProps, errors) {
+ return {
+ type: 0 /* TransitionAnimation */,
+ element: element,
+ triggerName: triggerName,
+ isRemovalTransition: isRemovalTransition,
+ fromState: fromState,
+ fromStyles: fromStyles,
+ toState: toState,
+ toStyles: toStyles,
+ timelines: timelines,
+ queriedElements: queriedElements,
+ preStyleProps: preStyleProps,
+ postStyleProps: postStyleProps,
+ errors: errors
+ };
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var AnimationTransitionFactory = (function () {
+ /**
+ * @param {?} _triggerName
+ * @param {?} ast
+ * @param {?} _stateStyles
+ */
+ function AnimationTransitionFactory(_triggerName, ast, _stateStyles) {
+ this._triggerName = _triggerName;
+ this.ast = ast;
+ this._stateStyles = _stateStyles;
+ }
+ /**
+ * @param {?} currentState
+ * @param {?} nextState
+ * @return {?}
+ */
+ AnimationTransitionFactory.prototype.match = function (currentState, nextState) {
+ return oneOrMoreTransitionsMatch(this.ast.matchers, currentState, nextState);
+ };
+ /**
+ * @param {?} driver
+ * @param {?} element
+ * @param {?} currentState
+ * @param {?} nextState
+ * @param {?=} options
+ * @param {?=} subInstructions
+ * @return {?}
+ */
+ AnimationTransitionFactory.prototype.build = function (driver, element, currentState, nextState, options, subInstructions) {
+ var /** @type {?} */ animationOptions = mergeAnimationOptions(this.ast.options || {}, options || {});
+ var /** @type {?} */ backupStateStyles = this._stateStyles['*'] || {};
+ var /** @type {?} */ currentStateStyles = this._stateStyles[currentState] || backupStateStyles;
+ var /** @type {?} */ nextStateStyles = this._stateStyles[nextState] || backupStateStyles;
+ var /** @type {?} */ queriedElements = new Set();
+ var /** @type {?} */ preStyleMap = new Map();
+ var /** @type {?} */ postStyleMap = new Map();
+ var /** @type {?} */ isRemoval = nextState === 'void';
+ var /** @type {?} */ errors = [];
+ var /** @type {?} */ timelines = buildAnimationTimelines(driver, element, this.ast.animation, currentStateStyles, nextStateStyles, animationOptions, subInstructions, errors);
+ if (errors.length) {
+ return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, [], [], preStyleMap, postStyleMap, errors);
+ }
+ timelines.forEach(function (tl) {
+ var /** @type {?} */ elm = tl.element;
+ var /** @type {?} */ preProps = getOrSetAsInMap(preStyleMap, elm, {});
+ tl.preStyleProps.forEach(function (prop) { return preProps[prop] = true; });
+ var /** @type {?} */ postProps = getOrSetAsInMap(postStyleMap, elm, {});
+ tl.postStyleProps.forEach(function (prop) { return postProps[prop] = true; });
+ if (elm !== element) {
+ queriedElements.add(elm);
+ }
+ });
+ var /** @type {?} */ queriedElementsList = iteratorToArray(queriedElements.values());
+ return createTransitionInstruction(element, this._triggerName, currentState, nextState, isRemoval, currentStateStyles, nextStateStyles, timelines, queriedElementsList, preStyleMap, postStyleMap);
+ };
+ return AnimationTransitionFactory;
+}());
+/**
+ * @param {?} matchFns
+ * @param {?} currentState
+ * @param {?} nextState
+ * @return {?}
+ */
+function oneOrMoreTransitionsMatch(matchFns, currentState, nextState) {
+ return matchFns.some(function (fn) { return fn(currentState, nextState); });
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * \@experimental Animation support is experimental.
+ * @param {?} name
+ * @param {?} ast
+ * @return {?}
+ */
+function buildTrigger(name, ast) {
+ return new AnimationTrigger(name, ast);
+}
+/**
+ * \@experimental Animation support is experimental.
+ */
+var AnimationTrigger = (function () {
+ /**
+ * @param {?} name
+ * @param {?} ast
+ */
+ function AnimationTrigger(name, ast) {
+ var _this = this;
+ this.name = name;
+ this.ast = ast;
+ this.transitionFactories = [];
+ this.states = {};
+ ast.states.forEach(function (ast) {
+ var obj = _this.states[ast.name] = {};
+ ast.style.styles.forEach(function (styleTuple) {
+ if (typeof styleTuple == 'object') {
+ copyStyles(styleTuple, false, obj);
+ }
+ });
+ });
+ balanceProperties(this.states, 'true', '1');
+ balanceProperties(this.states, 'false', '0');
+ ast.transitions.forEach(function (ast) {
+ _this.transitionFactories.push(new AnimationTransitionFactory(name, ast, _this.states));
+ });
+ this.fallbackTransition = createFallbackTransition(name, this.states);
+ }
+ Object.defineProperty(AnimationTrigger.prototype, "containsQueries", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this.ast.queryCount > 0; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} currentState
+ * @param {?} nextState
+ * @return {?}
+ */
+ AnimationTrigger.prototype.matchTransition = function (currentState, nextState) {
+ var /** @type {?} */ entry = this.transitionFactories.find(function (f) { return f.match(currentState, nextState); });
+ return entry || null;
+ };
+ return AnimationTrigger;
+}());
+/**
+ * @param {?} triggerName
+ * @param {?} states
+ * @return {?}
+ */
+function createFallbackTransition(triggerName, states) {
+ var /** @type {?} */ matchers = [function (fromState, toState) { return true; }];
+ var /** @type {?} */ animation = new SequenceAst([]);
+ var /** @type {?} */ transition = new TransitionAst(matchers, animation);
+ return new AnimationTransitionFactory(triggerName, transition, states);
+}
+/**
+ * @param {?} obj
+ * @param {?} key1
+ * @param {?} key2
+ * @return {?}
+ */
+function balanceProperties(obj, key1, key2) {
+ if (obj.hasOwnProperty(key1)) {
+ if (!obj.hasOwnProperty(key2)) {
+ obj[key2] = obj[key1];
+ }
+ }
+ else if (obj.hasOwnProperty(key2)) {
+ obj[key1] = obj[key2];
+ }
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var EMPTY_INSTRUCTION_MAP = new ElementInstructionMap();
+var TimelineAnimationEngine = (function () {
+ /**
+ * @param {?} _driver
+ * @param {?} _normalizer
+ */
+ function TimelineAnimationEngine(_driver, _normalizer) {
+ this._driver = _driver;
+ this._normalizer = _normalizer;
+ this._animations = {};
+ this._playersById = {};
+ this.players = [];
+ }
+ /**
+ * @param {?} id
+ * @param {?} metadata
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype.register = function (id, metadata) {
+ var /** @type {?} */ errors = [];
+ var /** @type {?} */ ast = buildAnimationAst(metadata, errors);
+ if (errors.length) {
+ throw new Error("Unable to build the animation due to the following errors: " + errors.join("\n"));
+ }
+ else {
+ this._animations[id] = ast;
+ }
+ };
+ /**
+ * @param {?} i
+ * @param {?} preStyles
+ * @param {?=} postStyles
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype._buildPlayer = function (i, preStyles, postStyles) {
+ var /** @type {?} */ element = i.element;
+ var /** @type {?} */ keyframes = normalizeKeyframes(this._driver, this._normalizer, element, i.keyframes, preStyles, postStyles);
+ return this._driver.animate(element, keyframes, i.duration, i.delay, i.easing, []);
+ };
+ /**
+ * @param {?} id
+ * @param {?} element
+ * @param {?=} options
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype.create = function (id, element, options) {
+ var _this = this;
+ if (options === void 0) { options = {}; }
+ var /** @type {?} */ errors = [];
+ var /** @type {?} */ ast = this._animations[id];
+ var /** @type {?} */ instructions;
+ var /** @type {?} */ autoStylesMap = new Map();
+ if (ast) {
+ instructions = buildAnimationTimelines(this._driver, element, ast, {}, {}, options, EMPTY_INSTRUCTION_MAP, errors);
+ instructions.forEach(function (inst) {
+ var /** @type {?} */ styles = getOrSetAsInMap(autoStylesMap, inst.element, {});
+ inst.postStyleProps.forEach(function (prop) { return styles[prop] = null; });
+ });
+ }
+ else {
+ errors.push('The requested animation doesn\'t exist or has already been destroyed');
+ instructions = [];
+ }
+ if (errors.length) {
+ throw new Error("Unable to create the animation due to the following errors: " + errors.join("\n"));
+ }
+ autoStylesMap.forEach(function (styles, element) {
+ Object.keys(styles).forEach(function (prop) { styles[prop] = _this._driver.computeStyle(element, prop, __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"]); });
+ });
+ var /** @type {?} */ players = instructions.map(function (i) {
+ var /** @type {?} */ styles = autoStylesMap.get(i.element);
+ return _this._buildPlayer(i, {}, styles);
+ });
+ var /** @type {?} */ player = optimizeGroupPlayer(players);
+ this._playersById[id] = player;
+ player.onDestroy(function () { return _this.destroy(id); });
+ this.players.push(player);
+ return player;
+ };
+ /**
+ * @param {?} id
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype.destroy = function (id) {
+ var /** @type {?} */ player = this._getPlayer(id);
+ player.destroy();
+ delete this._playersById[id];
+ var /** @type {?} */ index = this.players.indexOf(player);
+ if (index >= 0) {
+ this.players.splice(index, 1);
+ }
+ };
+ /**
+ * @param {?} id
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype._getPlayer = function (id) {
+ var /** @type {?} */ player = this._playersById[id];
+ if (!player) {
+ throw new Error("Unable to find the timeline player referenced by " + id);
+ }
+ return player;
+ };
+ /**
+ * @param {?} id
+ * @param {?} element
+ * @param {?} eventName
+ * @param {?} callback
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype.listen = function (id, element, eventName, callback) {
+ // triggerName, fromState, toState are all ignored for timeline animations
+ var /** @type {?} */ baseEvent = makeAnimationEvent(element, '', '', '');
+ listenOnPlayer(this._getPlayer(id), eventName, baseEvent, callback);
+ return function () { };
+ };
+ /**
+ * @param {?} id
+ * @param {?} element
+ * @param {?} command
+ * @param {?} args
+ * @return {?}
+ */
+ TimelineAnimationEngine.prototype.command = function (id, element, command, args) {
+ if (command == 'register') {
+ this.register(id, /** @type {?} */ (args[0]));
+ return;
+ }
+ if (command == 'create') {
+ var /** @type {?} */ options = ((args[0] || {}));
+ this.create(id, element, options);
+ return;
+ }
+ var /** @type {?} */ player = this._getPlayer(id);
+ switch (command) {
+ case 'play':
+ player.play();
+ break;
+ case 'pause':
+ player.pause();
+ break;
+ case 'reset':
+ player.reset();
+ break;
+ case 'restart':
+ player.restart();
+ break;
+ case 'finish':
+ player.finish();
+ break;
+ case 'init':
+ player.init();
+ break;
+ case 'setPosition':
+ player.setPosition(parseFloat(/** @type {?} */ (args[0])));
+ break;
+ case 'destroy':
+ this.destroy(id);
+ break;
+ }
+ };
+ return TimelineAnimationEngine;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var QUEUED_CLASSNAME = 'ng-animate-queued';
+var EMPTY_PLAYER_ARRAY = [];
+var NULL_REMOVAL_STATE = {
+ namespaceId: '',
+ setForRemoval: null,
+ hasAnimation: false,
+ removedBeforeQueried: false
+};
+var NULL_REMOVED_QUERIED_STATE = {
+ namespaceId: '',
+ setForRemoval: null,
+ hasAnimation: false,
+ removedBeforeQueried: true
+};
+var REMOVAL_FLAG = '__ng_removed';
+var StateValue = (function () {
+ /**
+ * @param {?} input
+ */
+ function StateValue(input) {
+ var isObj = input && input.hasOwnProperty('value');
+ var value = isObj ? input['value'] : input;
+ this.value = normalizeTriggerValue(value);
+ if (isObj) {
+ var options = copyObj(input);
+ delete options['value'];
+ this.options = options;
+ }
+ else {
+ this.options = {};
+ }
+ if (!this.options.params) {
+ this.options.params = {};
+ }
+ }
+ /**
+ * @param {?} options
+ * @return {?}
+ */
+ StateValue.prototype.absorbOptions = function (options) {
+ var /** @type {?} */ newParams = options.params;
+ if (newParams) {
+ var /** @type {?} */ oldParams_2 = ((this.options.params));
+ Object.keys(newParams).forEach(function (prop) {
+ if (oldParams_2[prop] == null) {
+ oldParams_2[prop] = newParams[prop];
+ }
+ });
+ }
+ };
+ return StateValue;
+}());
+var VOID_VALUE = 'void';
+var DEFAULT_STATE_VALUE = new StateValue(VOID_VALUE);
+var DELETED_STATE_VALUE = new StateValue('DELETED');
+var AnimationTransitionNamespace = (function () {
+ /**
+ * @param {?} id
+ * @param {?} hostElement
+ * @param {?} _engine
+ */
+ function AnimationTransitionNamespace(id, hostElement, _engine) {
+ this.id = id;
+ this.hostElement = hostElement;
+ this._engine = _engine;
+ this.players = [];
+ this._triggers = {};
+ this._queue = [];
+ this._elementListeners = new Map();
+ this._hostClassName = 'ng-tns-' + id;
+ addClass(hostElement, this._hostClassName);
+ }
+ /**
+ * @param {?} element
+ * @param {?} name
+ * @param {?} phase
+ * @param {?} callback
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.listen = function (element, name, phase, callback) {
+ var _this = this;
+ if (!this._triggers.hasOwnProperty(name)) {
+ throw new Error("Unable to listen on the animation trigger event \"" + phase + "\" because the animation trigger \"" + name + "\" doesn't exist!");
+ }
+ if (phase == null || phase.length == 0) {
+ throw new Error("Unable to listen on the animation trigger \"" + name + "\" because the provided event is undefined!");
+ }
+ if (!isTriggerEventValid(phase)) {
+ throw new Error("The provided animation trigger event \"" + phase + "\" for the animation trigger \"" + name + "\" is not supported!");
+ }
+ var /** @type {?} */ listeners = getOrSetAsInMap(this._elementListeners, element, []);
+ var /** @type {?} */ data = { name: name, phase: phase, callback: callback };
+ listeners.push(data);
+ var /** @type {?} */ triggersWithStates = getOrSetAsInMap(this._engine.statesByElement, element, {});
+ if (!triggersWithStates.hasOwnProperty(name)) {
+ addClass(element, NG_TRIGGER_CLASSNAME);
+ addClass(element, NG_TRIGGER_CLASSNAME + '-' + name);
+ triggersWithStates[name] = null;
+ }
+ return function () {
+ // the event listener is removed AFTER the flush has occurred such
+ // that leave animations callbacks can fire (otherwise if the node
+ // is removed in between then the listeners would be deregistered)
+ _this._engine.afterFlush(function () {
+ var /** @type {?} */ index = listeners.indexOf(data);
+ if (index >= 0) {
+ listeners.splice(index, 1);
+ }
+ if (!_this._triggers[name]) {
+ delete triggersWithStates[name];
+ }
+ });
+ };
+ };
+ /**
+ * @param {?} name
+ * @param {?} ast
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.register = function (name, ast) {
+ if (this._triggers[name]) {
+ // throw
+ return false;
+ }
+ else {
+ this._triggers[name] = ast;
+ return true;
+ }
+ };
+ /**
+ * @param {?} name
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype._getTrigger = function (name) {
+ var /** @type {?} */ trigger = this._triggers[name];
+ if (!trigger) {
+ throw new Error("The provided animation trigger \"" + name + "\" has not been registered!");
+ }
+ return trigger;
+ };
+ /**
+ * @param {?} element
+ * @param {?} triggerName
+ * @param {?} value
+ * @param {?=} defaultToFallback
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.trigger = function (element, triggerName, value, defaultToFallback) {
+ var _this = this;
+ if (defaultToFallback === void 0) { defaultToFallback = true; }
+ var /** @type {?} */ trigger = this._getTrigger(triggerName);
+ var /** @type {?} */ player = new TransitionAnimationPlayer(this.id, triggerName, element);
+ var /** @type {?} */ triggersWithStates = this._engine.statesByElement.get(element);
+ if (!triggersWithStates) {
+ addClass(element, NG_TRIGGER_CLASSNAME);
+ addClass(element, NG_TRIGGER_CLASSNAME + '-' + triggerName);
+ this._engine.statesByElement.set(element, triggersWithStates = {});
+ }
+ var /** @type {?} */ fromState = triggersWithStates[triggerName];
+ var /** @type {?} */ toState = new StateValue(value);
+ var /** @type {?} */ isObj = value && value.hasOwnProperty('value');
+ if (!isObj && fromState) {
+ toState.absorbOptions(fromState.options);
+ }
+ triggersWithStates[triggerName] = toState;
+ if (!fromState) {
+ fromState = DEFAULT_STATE_VALUE;
+ }
+ else if (fromState === DELETED_STATE_VALUE) {
+ return player;
+ }
+ var /** @type {?} */ isRemoval = toState.value === VOID_VALUE;
+ // normally this isn't reached by here, however, if an object expression
+ // is passed in then it may be a new object each time. Comparing the value
+ // is important since that will stay the same despite there being a new object.
+ // The removal arc here is special cased because the same element is triggered
+ // twice in the event that it contains animations on the outer/inner portions
+ // of the host container
+ if (!isRemoval && fromState.value === toState.value)
+ return;
+ var /** @type {?} */ playersOnElement = getOrSetAsInMap(this._engine.playersByElement, element, []);
+ playersOnElement.forEach(function (player) {
+ // only remove the player if it is queued on the EXACT same trigger/namespace
+ // we only also deal with queued players here because if the animation has
+ // started then we want to keep the player alive until the flush happens
+ // (which is where the previousPlayers are passed into the new palyer)
+ if (player.namespaceId == _this.id && player.triggerName == triggerName && player.queued) {
+ player.destroy();
+ }
+ });
+ var /** @type {?} */ transition = trigger.matchTransition(fromState.value, toState.value);
+ var /** @type {?} */ isFallbackTransition = false;
+ if (!transition) {
+ if (!defaultToFallback)
+ return;
+ transition = trigger.fallbackTransition;
+ isFallbackTransition = true;
+ }
+ this._engine.totalQueuedPlayers++;
+ this._queue.push({ element: element, triggerName: triggerName, transition: transition, fromState: fromState, toState: toState, player: player, isFallbackTransition: isFallbackTransition });
+ if (!isFallbackTransition) {
+ addClass(element, QUEUED_CLASSNAME);
+ player.onStart(function () { removeClass(element, QUEUED_CLASSNAME); });
+ }
+ player.onDone(function () {
+ var /** @type {?} */ index = _this.players.indexOf(player);
+ if (index >= 0) {
+ _this.players.splice(index, 1);
+ }
+ var /** @type {?} */ players = _this._engine.playersByElement.get(element);
+ if (players) {
+ var /** @type {?} */ index_1 = players.indexOf(player);
+ if (index_1 >= 0) {
+ players.splice(index_1, 1);
+ }
+ }
+ });
+ this.players.push(player);
+ playersOnElement.push(player);
+ return player;
+ };
+ /**
+ * @param {?} name
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.deregister = function (name) {
+ var _this = this;
+ delete this._triggers[name];
+ this._engine.statesByElement.forEach(function (stateMap, element) { delete stateMap[name]; });
+ this._elementListeners.forEach(function (listeners, element) {
+ _this._elementListeners.set(element, listeners.filter(function (entry) { return entry.name != name; }));
+ });
+ };
+ /**
+ * @param {?} element
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.clearElementCache = function (element) {
+ this._engine.statesByElement.delete(element);
+ this._elementListeners.delete(element);
+ var /** @type {?} */ elementPlayers = this._engine.playersByElement.get(element);
+ if (elementPlayers) {
+ elementPlayers.forEach(function (player) { return player.destroy(); });
+ this._engine.playersByElement.delete(element);
+ }
+ };
+ /**
+ * @param {?} rootElement
+ * @param {?} context
+ * @param {?=} animate
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype._destroyInnerNodes = function (rootElement, context, animate) {
+ var _this = this;
+ if (animate === void 0) { animate = false; }
+ this._engine.driver.query(rootElement, NG_TRIGGER_SELECTOR, true).forEach(function (elm) {
+ if (animate && containsClass(elm, _this._hostClassName)) {
+ var /** @type {?} */ innerNs = _this._engine.namespacesByHostElement.get(elm);
+ // special case for a host element with animations on the same element
+ if (innerNs) {
+ innerNs.removeNode(elm, context, true);
+ }
+ _this.removeNode(elm, context, true);
+ }
+ else {
+ _this.clearElementCache(elm);
+ }
+ });
+ };
+ /**
+ * @param {?} element
+ * @param {?} context
+ * @param {?=} doNotRecurse
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.removeNode = function (element, context, doNotRecurse) {
+ var _this = this;
+ var /** @type {?} */ engine = this._engine;
+ if (!doNotRecurse && element.childElementCount) {
+ this._destroyInnerNodes(element, context, true);
+ }
+ var /** @type {?} */ triggerStates = engine.statesByElement.get(element);
+ if (triggerStates) {
+ var /** @type {?} */ players_1 = [];
+ Object.keys(triggerStates).forEach(function (triggerName) {
+ // this check is here in the event that an element is removed
+ // twice (both on the host level and the component level)
+ if (_this._triggers[triggerName]) {
+ var /** @type {?} */ player = _this.trigger(element, triggerName, VOID_VALUE, false);
+ if (player) {
+ players_1.push(player);
+ }
+ }
+ });
+ if (players_1.length) {
+ engine.markElementAsRemoved(this.id, element, true, context);
+ optimizeGroupPlayer(players_1).onDone(function () { return engine.processLeaveNode(element); });
+ return;
+ }
+ }
+ // find the player that is animating and make sure that the
+ // removal is delayed until that player has completed
+ var /** @type {?} */ containsPotentialParentTransition = false;
+ if (engine.totalAnimations) {
+ var /** @type {?} */ currentPlayers = engine.players.length ? engine.playersByQueriedElement.get(element) : [];
+ // when this `if statement` does not continue forward it means that
+ // a previous animation query has selected the current element and
+ // is animating it. In this situation want to continue fowards and
+ // allow the element to be queued up for animation later.
+ if (currentPlayers && currentPlayers.length) {
+ containsPotentialParentTransition = true;
+ }
+ else {
+ var /** @type {?} */ parent = element;
+ while (parent = parent.parentNode) {
+ var /** @type {?} */ triggers = engine.statesByElement.get(parent);
+ if (triggers) {
+ containsPotentialParentTransition = true;
+ break;
+ }
+ }
+ }
+ }
+ // at this stage we know that the element will either get removed
+ // during flush or will be picked up by a parent query. Either way
+ // we need to fire the listeners for this element when it DOES get
+ // removed (once the query parent animation is done or after flush)
+ var /** @type {?} */ listeners = this._elementListeners.get(element);
+ if (listeners) {
+ var /** @type {?} */ visitedTriggers_1 = new Set();
+ listeners.forEach(function (listener) {
+ var /** @type {?} */ triggerName = listener.name;
+ if (visitedTriggers_1.has(triggerName))
+ return;
+ visitedTriggers_1.add(triggerName);
+ var /** @type {?} */ trigger = _this._triggers[triggerName];
+ var /** @type {?} */ transition = trigger.fallbackTransition;
+ var /** @type {?} */ elementStates = ((engine.statesByElement.get(element)));
+ var /** @type {?} */ fromState = elementStates[triggerName] || DEFAULT_STATE_VALUE;
+ var /** @type {?} */ toState = new StateValue(VOID_VALUE);
+ var /** @type {?} */ player = new TransitionAnimationPlayer(_this.id, triggerName, element);
+ _this._engine.totalQueuedPlayers++;
+ _this._queue.push({
+ element: element,
+ triggerName: triggerName,
+ transition: transition,
+ fromState: fromState,
+ toState: toState,
+ player: player,
+ isFallbackTransition: true
+ });
+ });
+ }
+ // whether or not a parent has an animation we need to delay the deferral of the leave
+ // operation until we have more information (which we do after flush() has been called)
+ if (containsPotentialParentTransition) {
+ engine.markElementAsRemoved(this.id, element, false, context);
+ }
+ else {
+ // we do this after the flush has occurred such
+ // that the callbacks can be fired
+ engine.afterFlush(function () { return _this.clearElementCache(element); });
+ engine.destroyInnerAnimations(element);
+ engine._onRemovalComplete(element, context);
+ }
+ };
+ /**
+ * @param {?} element
+ * @param {?} parent
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.insertNode = function (element, parent) { addClass(element, this._hostClassName); };
+ /**
+ * @param {?} microtaskId
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.drainQueuedTransitions = function (microtaskId) {
+ var _this = this;
+ var /** @type {?} */ instructions = [];
+ this._queue.forEach(function (entry) {
+ var /** @type {?} */ player = entry.player;
+ if (player.destroyed)
+ return;
+ var /** @type {?} */ element = entry.element;
+ var /** @type {?} */ listeners = _this._elementListeners.get(element);
+ if (listeners) {
+ listeners.forEach(function (listener) {
+ if (listener.name == entry.triggerName) {
+ var /** @type {?} */ baseEvent = makeAnimationEvent(element, entry.triggerName, entry.fromState.value, entry.toState.value);
+ ((baseEvent))['_data'] = microtaskId;
+ listenOnPlayer(entry.player, listener.phase, baseEvent, listener.callback);
+ }
+ });
+ }
+ if (player.markedForDestroy) {
+ _this._engine.afterFlush(function () {
+ // now we can destroy the element properly since the event listeners have
+ // been bound to the player
+ player.destroy();
+ });
+ }
+ else {
+ instructions.push(entry);
+ }
+ });
+ this._queue = [];
+ return instructions.sort(function (a, b) {
+ // if depCount == 0 them move to front
+ // otherwise if a contains b then move back
+ var /** @type {?} */ d0 = a.transition.ast.depCount;
+ var /** @type {?} */ d1 = b.transition.ast.depCount;
+ if (d0 == 0 || d1 == 0) {
+ return d0 - d1;
+ }
+ return _this._engine.driver.containsElement(a.element, b.element) ? 1 : -1;
+ });
+ };
+ /**
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.destroy = function (context) {
+ this.players.forEach(function (p) { return p.destroy(); });
+ this._destroyInnerNodes(this.hostElement, context);
+ };
+ /**
+ * @param {?} element
+ * @return {?}
+ */
+ AnimationTransitionNamespace.prototype.elementContainsData = function (element) {
+ var /** @type {?} */ containsData = false;
+ if (this._elementListeners.has(element))
+ containsData = true;
+ containsData =
+ (this._queue.find(function (entry) { return entry.element === element; }) ? true : false) || containsData;
+ return containsData;
+ };
+ return AnimationTransitionNamespace;
+}());
+var TransitionAnimationEngine = (function () {
+ /**
+ * @param {?} driver
+ * @param {?} _normalizer
+ */
+ function TransitionAnimationEngine(driver, _normalizer) {
+ this.driver = driver;
+ this._normalizer = _normalizer;
+ this.players = [];
+ this.newHostElements = new Map();
+ this.playersByElement = new Map();
+ this.playersByQueriedElement = new Map();
+ this.statesByElement = new Map();
+ this.totalAnimations = 0;
+ this.totalQueuedPlayers = 0;
+ this._namespaceLookup = {};
+ this._namespaceList = [];
+ this._flushFns = [];
+ this._whenQuietFns = [];
+ this.namespacesByHostElement = new Map();
+ this.collectedEnterElements = [];
+ this.collectedLeaveElements = [];
+ this.onRemovalComplete = function (element, context) { };
+ }
+ /**
+ * @param {?} element
+ * @param {?} context
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._onRemovalComplete = function (element, context) { this.onRemovalComplete(element, context); };
+ Object.defineProperty(TransitionAnimationEngine.prototype, "queuedPlayers", {
+ /**
+ * @return {?}
+ */
+ get: function () {
+ var /** @type {?} */ players = [];
+ this._namespaceList.forEach(function (ns) {
+ ns.players.forEach(function (player) {
+ if (player.queued) {
+ players.push(player);
+ }
+ });
+ });
+ return players;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} namespaceId
+ * @param {?} hostElement
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.createNamespace = function (namespaceId, hostElement) {
+ var /** @type {?} */ ns = new AnimationTransitionNamespace(namespaceId, hostElement, this);
+ if (hostElement.parentNode) {
+ this._balanceNamespaceList(ns, hostElement);
+ }
+ else {
+ // defer this later until flush during when the host element has
+ // been inserted so that we know exactly where to place it in
+ // the namespace list
+ this.newHostElements.set(hostElement, ns);
+ // given that this host element is apart of the animation code, it
+ // may or may not be inserted by a parent node that is an of an
+ // animation renderer type. If this happens then we can still have
+ // access to this item when we query for :enter nodes. If the parent
+ // is a renderer then the set data-structure will normalize the entry
+ this.collectEnterElement(hostElement);
+ }
+ return this._namespaceLookup[namespaceId] = ns;
+ };
+ /**
+ * @param {?} ns
+ * @param {?} hostElement
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._balanceNamespaceList = function (ns, hostElement) {
+ var /** @type {?} */ limit = this._namespaceList.length - 1;
+ if (limit >= 0) {
+ var /** @type {?} */ found = false;
+ for (var /** @type {?} */ i = limit; i >= 0; i--) {
+ var /** @type {?} */ nextNamespace = this._namespaceList[i];
+ if (this.driver.containsElement(nextNamespace.hostElement, hostElement)) {
+ this._namespaceList.splice(i + 1, 0, ns);
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ this._namespaceList.splice(0, 0, ns);
+ }
+ }
+ else {
+ this._namespaceList.push(ns);
+ }
+ this.namespacesByHostElement.set(hostElement, ns);
+ return ns;
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} hostElement
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.register = function (namespaceId, hostElement) {
+ var /** @type {?} */ ns = this._namespaceLookup[namespaceId];
+ if (!ns) {
+ ns = this.createNamespace(namespaceId, hostElement);
+ }
+ return ns;
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} name
+ * @param {?} trigger
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.registerTrigger = function (namespaceId, name, trigger) {
+ var /** @type {?} */ ns = this._namespaceLookup[namespaceId];
+ if (ns && ns.register(name, trigger)) {
+ this.totalAnimations++;
+ }
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} context
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.destroy = function (namespaceId, context) {
+ var _this = this;
+ if (!namespaceId)
+ return;
+ var /** @type {?} */ ns = this._fetchNamespace(namespaceId);
+ this.afterFlush(function () {
+ _this.namespacesByHostElement.delete(ns.hostElement);
+ delete _this._namespaceLookup[namespaceId];
+ var /** @type {?} */ index = _this._namespaceList.indexOf(ns);
+ if (index >= 0) {
+ _this._namespaceList.splice(index, 1);
+ }
+ });
+ this.afterFlushAnimationsDone(function () { return ns.destroy(context); });
+ };
+ /**
+ * @param {?} id
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._fetchNamespace = function (id) { return this._namespaceLookup[id]; };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} name
+ * @param {?} value
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.trigger = function (namespaceId, element, name, value) {
+ if (isElementNode(element)) {
+ this._fetchNamespace(namespaceId).trigger(element, name, value);
+ return true;
+ }
+ return false;
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} parent
+ * @param {?} insertBefore
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.insertNode = function (namespaceId, element, parent, insertBefore) {
+ if (!isElementNode(element))
+ return;
+ // special case for when an element is removed and reinserted (move operation)
+ // when this occurs we do not want to use the element for deletion later
+ var /** @type {?} */ details = (element[REMOVAL_FLAG]);
+ if (details && details.setForRemoval) {
+ details.setForRemoval = false;
+ }
+ // in the event that the namespaceId is blank then the caller
+ // code does not contain any animation code in it, but it is
+ // just being called so that the node is marked as being inserted
+ if (namespaceId) {
+ this._fetchNamespace(namespaceId).insertNode(element, parent);
+ }
+ // only *directives and host elements are inserted before
+ if (insertBefore) {
+ this.collectEnterElement(element);
+ }
+ };
+ /**
+ * @param {?} element
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.collectEnterElement = function (element) { this.collectedEnterElements.push(element); };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} context
+ * @param {?=} doNotRecurse
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.removeNode = function (namespaceId, element, context, doNotRecurse) {
+ if (!isElementNode(element)) {
+ this._onRemovalComplete(element, context);
+ return;
+ }
+ var /** @type {?} */ ns = namespaceId ? this._fetchNamespace(namespaceId) : null;
+ if (ns) {
+ ns.removeNode(element, context, doNotRecurse);
+ }
+ else {
+ this.markElementAsRemoved(namespaceId, element, false, context);
+ }
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?=} hasAnimation
+ * @param {?=} context
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.markElementAsRemoved = function (namespaceId, element, hasAnimation, context) {
+ this.collectedLeaveElements.push(element);
+ element[REMOVAL_FLAG] = {
+ namespaceId: namespaceId,
+ setForRemoval: context, hasAnimation: hasAnimation,
+ removedBeforeQueried: false
+ };
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} name
+ * @param {?} phase
+ * @param {?} callback
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.listen = function (namespaceId, element, name, phase, callback) {
+ if (isElementNode(element)) {
+ return this._fetchNamespace(namespaceId).listen(element, name, phase, callback);
+ }
+ return function () { };
+ };
+ /**
+ * @param {?} entry
+ * @param {?} subTimelines
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._buildInstruction = function (entry, subTimelines) {
+ return entry.transition.build(this.driver, entry.element, entry.fromState.value, entry.toState.value, entry.toState.options, subTimelines);
+ };
+ /**
+ * @param {?} containerElement
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.destroyInnerAnimations = function (containerElement) {
+ var _this = this;
+ var /** @type {?} */ elements = this.driver.query(containerElement, NG_TRIGGER_SELECTOR, true);
+ elements.forEach(function (element) {
+ var /** @type {?} */ players = _this.playersByElement.get(element);
+ if (players) {
+ players.forEach(function (player) {
+ // special case for when an element is set for destruction, but hasn't started.
+ // in this situation we want to delay the destruction until the flush occurs
+ // so that any event listeners attached to the player are triggered.
+ if (player.queued) {
+ player.markedForDestroy = true;
+ }
+ else {
+ player.destroy();
+ }
+ });
+ }
+ var /** @type {?} */ stateMap = _this.statesByElement.get(element);
+ if (stateMap) {
+ Object.keys(stateMap).forEach(function (triggerName) { return stateMap[triggerName] = DELETED_STATE_VALUE; });
+ }
+ });
+ if (this.playersByQueriedElement.size == 0)
+ return;
+ elements = this.driver.query(containerElement, NG_ANIMATING_SELECTOR, true);
+ if (elements.length) {
+ elements.forEach(function (element) {
+ var /** @type {?} */ players = _this.playersByQueriedElement.get(element);
+ if (players) {
+ players.forEach(function (player) { return player.finish(); });
+ }
+ });
+ }
+ };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.whenRenderingDone = function () {
+ var _this = this;
+ return new Promise(function (resolve) {
+ if (_this.players.length) {
+ return optimizeGroupPlayer(_this.players).onDone(function () { return resolve(); });
+ }
+ else {
+ resolve();
+ }
+ });
+ };
+ /**
+ * @param {?} element
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.processLeaveNode = function (element) {
+ var /** @type {?} */ details = (element[REMOVAL_FLAG]);
+ if (details && details.setForRemoval) {
+ // this will prevent it from removing it twice
+ element[REMOVAL_FLAG] = NULL_REMOVAL_STATE;
+ if (details.namespaceId) {
+ this.destroyInnerAnimations(element);
+ var /** @type {?} */ ns = this._fetchNamespace(details.namespaceId);
+ if (ns) {
+ ns.clearElementCache(element);
+ }
+ }
+ this._onRemovalComplete(element, details.setForRemoval);
+ }
+ };
+ /**
+ * @param {?=} microtaskId
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.flush = function (microtaskId) {
+ var _this = this;
+ if (microtaskId === void 0) { microtaskId = -1; }
+ var /** @type {?} */ players = [];
+ if (this.newHostElements.size) {
+ this.newHostElements.forEach(function (ns, element) { return _this._balanceNamespaceList(ns, element); });
+ this.newHostElements.clear();
+ }
+ if (this._namespaceList.length &&
+ (this.totalQueuedPlayers || this.collectedLeaveElements.length)) {
+ var /** @type {?} */ cleanupFns = [];
+ try {
+ players = this._flushAnimations(cleanupFns, microtaskId);
+ }
+ finally {
+ for (var /** @type {?} */ i = 0; i < cleanupFns.length; i++) {
+ cleanupFns[i]();
+ }
+ }
+ }
+ else {
+ for (var /** @type {?} */ i = 0; i < this.collectedLeaveElements.length; i++) {
+ var /** @type {?} */ element = this.collectedLeaveElements[i];
+ this.processLeaveNode(element);
+ }
+ }
+ this.totalQueuedPlayers = 0;
+ this.collectedEnterElements.length = 0;
+ this.collectedLeaveElements.length = 0;
+ this._flushFns.forEach(function (fn) { return fn(); });
+ this._flushFns = [];
+ if (this._whenQuietFns.length) {
+ // we move these over to a variable so that
+ // if any new callbacks are registered in another
+ // flush they do not populate the existing set
+ var /** @type {?} */ quietFns_1 = this._whenQuietFns;
+ this._whenQuietFns = [];
+ if (players.length) {
+ optimizeGroupPlayer(players).onDone(function () { quietFns_1.forEach(function (fn) { return fn(); }); });
+ }
+ else {
+ quietFns_1.forEach(function (fn) { return fn(); });
+ }
+ }
+ };
+ /**
+ * @param {?} cleanupFns
+ * @param {?} microtaskId
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._flushAnimations = function (cleanupFns, microtaskId) {
+ var _this = this;
+ var /** @type {?} */ subTimelines = new ElementInstructionMap();
+ var /** @type {?} */ skippedPlayers = [];
+ var /** @type {?} */ skippedPlayersMap = new Map();
+ var /** @type {?} */ queuedInstructions = [];
+ var /** @type {?} */ queriedElements = new Map();
+ var /** @type {?} */ allPreStyleElements = new Map();
+ var /** @type {?} */ allPostStyleElements = new Map();
+ var /** @type {?} */ bodyNode = getBodyNode();
+ var /** @type {?} */ allEnterNodes = this.collectedEnterElements.length ?
+ this.collectedEnterElements.filter(createIsRootFilterFn(this.collectedEnterElements)) :
+ [];
+ // this must occur before the instructions are built below such that
+ // the :enter queries match the elements (since the timeline queries
+ // are fired during instruction building).
+ for (var /** @type {?} */ i = 0; i < allEnterNodes.length; i++) {
+ addClass(allEnterNodes[i], ENTER_CLASSNAME);
+ }
+ var /** @type {?} */ allLeaveNodes = [];
+ var /** @type {?} */ leaveNodesWithoutAnimations = [];
+ for (var /** @type {?} */ i = 0; i < this.collectedLeaveElements.length; i++) {
+ var /** @type {?} */ element = this.collectedLeaveElements[i];
+ var /** @type {?} */ details = (element[REMOVAL_FLAG]);
+ if (details && details.setForRemoval) {
+ addClass(element, LEAVE_CLASSNAME);
+ allLeaveNodes.push(element);
+ if (!details.hasAnimation) {
+ leaveNodesWithoutAnimations.push(element);
+ }
+ }
+ }
+ cleanupFns.push(function () {
+ allEnterNodes.forEach(function (element) { return removeClass(element, ENTER_CLASSNAME); });
+ allLeaveNodes.forEach(function (element) {
+ removeClass(element, LEAVE_CLASSNAME);
+ _this.processLeaveNode(element);
+ });
+ });
+ var /** @type {?} */ allPlayers = [];
+ var /** @type {?} */ erroneousTransitions = [];
+ for (var /** @type {?} */ i = this._namespaceList.length - 1; i >= 0; i--) {
+ var /** @type {?} */ ns = this._namespaceList[i];
+ ns.drainQueuedTransitions(microtaskId).forEach(function (entry) {
+ var /** @type {?} */ player = entry.player;
+ allPlayers.push(player);
+ var /** @type {?} */ element = entry.element;
+ if (!bodyNode || !_this.driver.containsElement(bodyNode, element)) {
+ player.destroy();
+ return;
+ }
+ var /** @type {?} */ instruction = ((_this._buildInstruction(entry, subTimelines)));
+ if (instruction.errors && instruction.errors.length) {
+ erroneousTransitions.push(instruction);
+ return;
+ }
+ // if a unmatched transition is queued to go then it SHOULD NOT render
+ // an animation and cancel the previously running animations.
+ if (entry.isFallbackTransition) {
+ player.onStart(function () { return eraseStyles(element, instruction.fromStyles); });
+ player.onDestroy(function () { return setStyles(element, instruction.toStyles); });
+ skippedPlayers.push(player);
+ return;
+ }
+ // this means that if a parent animation uses this animation as a sub trigger
+ // then it will instruct the timeline builder to not add a player delay, but
+ // instead stretch the first keyframe gap up until the animation starts. The
+ // reason this is important is to prevent extra initialization styles from being
+ // required by the user in the animation.
+ instruction.timelines.forEach(function (tl) { return tl.stretchStartingKeyframe = true; });
+ subTimelines.append(element, instruction.timelines);
+ var /** @type {?} */ tuple = { instruction: instruction, player: player, element: element };
+ queuedInstructions.push(tuple);
+ instruction.queriedElements.forEach(function (element) { return getOrSetAsInMap(queriedElements, element, []).push(player); });
+ instruction.preStyleProps.forEach(function (stringMap, element) {
+ var /** @type {?} */ props = Object.keys(stringMap);
+ if (props.length) {
+ var /** @type {?} */ setVal_1 = ((allPreStyleElements.get(element)));
+ if (!setVal_1) {
+ allPreStyleElements.set(element, setVal_1 = new Set());
+ }
+ props.forEach(function (prop) { return setVal_1.add(prop); });
+ }
+ });
+ instruction.postStyleProps.forEach(function (stringMap, element) {
+ var /** @type {?} */ props = Object.keys(stringMap);
+ var /** @type {?} */ setVal = ((allPostStyleElements.get(element)));
+ if (!setVal) {
+ allPostStyleElements.set(element, setVal = new Set());
+ }
+ props.forEach(function (prop) { return setVal.add(prop); });
+ });
+ });
+ }
+ if (erroneousTransitions.length) {
+ var /** @type {?} */ msg_1 = "Unable to process animations due to the following failed trigger transitions\n";
+ erroneousTransitions.forEach(function (instruction) {
+ msg_1 += "@" + instruction.triggerName + " has failed due to:\n"; /** @type {?} */
+ ((instruction.errors)).forEach(function (error) { msg_1 += "- " + error + "\n"; });
+ });
+ allPlayers.forEach(function (player) { return player.destroy(); });
+ throw new Error(msg_1);
+ }
+ // these can only be detected here since we have a map of all the elements
+ // that have animations attached to them...
+ var /** @type {?} */ enterNodesWithoutAnimations = [];
+ for (var /** @type {?} */ i = 0; i < allEnterNodes.length; i++) {
+ var /** @type {?} */ element = allEnterNodes[i];
+ if (!subTimelines.has(element)) {
+ enterNodesWithoutAnimations.push(element);
+ }
+ }
+ var /** @type {?} */ allPreviousPlayersMap = new Map();
+ var /** @type {?} */ sortedParentElements = [];
+ queuedInstructions.forEach(function (entry) {
+ var /** @type {?} */ element = entry.element;
+ if (subTimelines.has(element)) {
+ sortedParentElements.unshift(element);
+ _this._beforeAnimationBuild(entry.player.namespaceId, entry.instruction, allPreviousPlayersMap);
+ }
+ });
+ skippedPlayers.forEach(function (player) {
+ var /** @type {?} */ element = player.element;
+ var /** @type {?} */ previousPlayers = _this._getPreviousPlayers(element, false, player.namespaceId, player.triggerName, null);
+ previousPlayers.forEach(function (prevPlayer) { getOrSetAsInMap(allPreviousPlayersMap, element, []).push(prevPlayer); });
+ });
+ allPreviousPlayersMap.forEach(function (players) { return players.forEach(function (player) { return player.destroy(); }); });
+ // PRE STAGE: fill the ! styles
+ var /** @type {?} */ preStylesMap = allPreStyleElements.size ?
+ cloakAndComputeStyles(this.driver, enterNodesWithoutAnimations, allPreStyleElements, __WEBPACK_IMPORTED_MODULE_1__angular_animations__["ɵPRE_STYLE"]) :
+ new Map();
+ // POST STAGE: fill the * styles
+ var /** @type {?} */ postStylesMap = cloakAndComputeStyles(this.driver, leaveNodesWithoutAnimations, allPostStyleElements, __WEBPACK_IMPORTED_MODULE_1__angular_animations__["AUTO_STYLE"]);
+ var /** @type {?} */ rootPlayers = [];
+ var /** @type {?} */ subPlayers = [];
+ queuedInstructions.forEach(function (entry) {
+ var element = entry.element, player = entry.player, instruction = entry.instruction;
+ // this means that it was never consumed by a parent animation which
+ // means that it is independent and therefore should be set for animation
+ if (subTimelines.has(element)) {
+ var /** @type {?} */ innerPlayer = _this._buildAnimation(player.namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap);
+ player.setRealPlayer(innerPlayer);
+ var /** @type {?} */ parentHasPriority = null;
+ for (var /** @type {?} */ i = 0; i < sortedParentElements.length; i++) {
+ var /** @type {?} */ parent = sortedParentElements[i];
+ if (parent === element)
+ break;
+ if (_this.driver.containsElement(parent, element)) {
+ parentHasPriority = parent;
+ break;
+ }
+ }
+ if (parentHasPriority) {
+ var /** @type {?} */ parentPlayers = _this.playersByElement.get(parentHasPriority);
+ if (parentPlayers && parentPlayers.length) {
+ player.parentPlayer = optimizeGroupPlayer(parentPlayers);
+ }
+ skippedPlayers.push(player);
+ }
+ else {
+ rootPlayers.push(player);
+ }
+ }
+ else {
+ eraseStyles(element, instruction.fromStyles);
+ player.onDestroy(function () { return setStyles(element, instruction.toStyles); });
+ subPlayers.push(player);
+ }
+ });
+ subPlayers.forEach(function (player) {
+ var /** @type {?} */ playersForElement = skippedPlayersMap.get(player.element);
+ if (playersForElement && playersForElement.length) {
+ var /** @type {?} */ innerPlayer = optimizeGroupPlayer(playersForElement);
+ player.setRealPlayer(innerPlayer);
+ }
+ });
+ // the reason why we don't actually play the animation is
+ // because all that a skipped player is designed to do is to
+ // fire the start/done transition callback events
+ skippedPlayers.forEach(function (player) {
+ if (player.parentPlayer) {
+ player.parentPlayer.onDestroy(function () { return player.destroy(); });
+ }
+ else {
+ player.destroy();
+ }
+ });
+ // run through all of the queued removals and see if they
+ // were picked up by a query. If not then perform the removal
+ // operation right away unless a parent animation is ongoing.
+ for (var /** @type {?} */ i = 0; i < allLeaveNodes.length; i++) {
+ var /** @type {?} */ element = allLeaveNodes[i];
+ var /** @type {?} */ details = (element[REMOVAL_FLAG]);
+ removeClass(element, LEAVE_CLASSNAME);
+ // this means the element has a removal animation that is being
+ // taken care of and therefore the inner elements will hang around
+ // until that animation is over (or the parent queried animation)
+ if (details && details.hasAnimation)
+ continue;
+ var /** @type {?} */ players = [];
+ // if this element is queried or if it contains queried children
+ // then we want for the element not to be removed from the page
+ // until the queried animations have finished
+ if (queriedElements.size) {
+ var /** @type {?} */ queriedPlayerResults = queriedElements.get(element);
+ if (queriedPlayerResults && queriedPlayerResults.length) {
+ players.push.apply(players, queriedPlayerResults);
+ }
+ var /** @type {?} */ queriedInnerElements = this.driver.query(element, NG_ANIMATING_SELECTOR, true);
+ for (var /** @type {?} */ j = 0; j < queriedInnerElements.length; j++) {
+ var /** @type {?} */ queriedPlayers = queriedElements.get(queriedInnerElements[j]);
+ if (queriedPlayers && queriedPlayers.length) {
+ players.push.apply(players, queriedPlayers);
+ }
+ }
+ }
+ if (players.length) {
+ removeNodesAfterAnimationDone(this, element, players);
+ }
+ else {
+ this.processLeaveNode(element);
+ }
+ }
+ // this is required so the cleanup method doesn't remove them
+ allLeaveNodes.length = 0;
+ rootPlayers.forEach(function (player) {
+ _this.players.push(player);
+ player.onDone(function () {
+ player.destroy();
+ var /** @type {?} */ index = _this.players.indexOf(player);
+ _this.players.splice(index, 1);
+ });
+ player.play();
+ });
+ return rootPlayers;
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.elementContainsData = function (namespaceId, element) {
+ var /** @type {?} */ containsData = false;
+ var /** @type {?} */ details = (element[REMOVAL_FLAG]);
+ if (details && details.setForRemoval)
+ containsData = true;
+ if (this.playersByElement.has(element))
+ containsData = true;
+ if (this.playersByQueriedElement.has(element))
+ containsData = true;
+ if (this.statesByElement.has(element))
+ containsData = true;
+ return this._fetchNamespace(namespaceId).elementContainsData(element) || containsData;
+ };
+ /**
+ * @param {?} callback
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.afterFlush = function (callback) { this._flushFns.push(callback); };
+ /**
+ * @param {?} callback
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype.afterFlushAnimationsDone = function (callback) { this._whenQuietFns.push(callback); };
+ /**
+ * @param {?} element
+ * @param {?} isQueriedElement
+ * @param {?=} namespaceId
+ * @param {?=} triggerName
+ * @param {?=} toStateValue
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._getPreviousPlayers = function (element, isQueriedElement, namespaceId, triggerName, toStateValue) {
+ var /** @type {?} */ players = [];
+ if (isQueriedElement) {
+ var /** @type {?} */ queriedElementPlayers = this.playersByQueriedElement.get(element);
+ if (queriedElementPlayers) {
+ players = queriedElementPlayers;
+ }
+ }
+ else {
+ var /** @type {?} */ elementPlayers = this.playersByElement.get(element);
+ if (elementPlayers) {
+ var /** @type {?} */ isRemovalAnimation_1 = !toStateValue || toStateValue == VOID_VALUE;
+ elementPlayers.forEach(function (player) {
+ if (player.queued)
+ return;
+ if (!isRemovalAnimation_1 && player.triggerName != triggerName)
+ return;
+ players.push(player);
+ });
+ }
+ }
+ if (namespaceId || triggerName) {
+ players = players.filter(function (player) {
+ if (namespaceId && namespaceId != player.namespaceId)
+ return false;
+ if (triggerName && triggerName != player.triggerName)
+ return false;
+ return true;
+ });
+ }
+ return players;
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} instruction
+ * @param {?} allPreviousPlayersMap
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._beforeAnimationBuild = function (namespaceId, instruction, allPreviousPlayersMap) {
+ var _this = this;
+ // it's important to do this step before destroying the players
+ // so that the onDone callback below won't fire before this
+ eraseStyles(instruction.element, instruction.fromStyles);
+ var /** @type {?} */ triggerName = instruction.triggerName;
+ var /** @type {?} */ rootElement = instruction.element;
+ // when a removal animation occurs, ALL previous players are collected
+ // and destroyed (even if they are outside of the current namespace)
+ var /** @type {?} */ targetNameSpaceId = instruction.isRemovalTransition ? undefined : namespaceId;
+ var /** @type {?} */ targetTriggerName = instruction.isRemovalTransition ? undefined : triggerName;
+ instruction.timelines.map(function (timelineInstruction) {
+ var /** @type {?} */ element = timelineInstruction.element;
+ var /** @type {?} */ isQueriedElement = element !== rootElement;
+ var /** @type {?} */ players = getOrSetAsInMap(allPreviousPlayersMap, element, []);
+ var /** @type {?} */ previousPlayers = _this._getPreviousPlayers(element, isQueriedElement, targetNameSpaceId, targetTriggerName, instruction.toState);
+ previousPlayers.forEach(function (player) {
+ var /** @type {?} */ realPlayer = (player.getRealPlayer());
+ if (realPlayer.beforeDestroy) {
+ realPlayer.beforeDestroy();
+ }
+ players.push(player);
+ });
+ });
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} instruction
+ * @param {?} allPreviousPlayersMap
+ * @param {?} skippedPlayersMap
+ * @param {?} preStylesMap
+ * @param {?} postStylesMap
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._buildAnimation = function (namespaceId, instruction, allPreviousPlayersMap, skippedPlayersMap, preStylesMap, postStylesMap) {
+ var _this = this;
+ var /** @type {?} */ triggerName = instruction.triggerName;
+ var /** @type {?} */ rootElement = instruction.element;
+ // we first run this so that the previous animation player
+ // data can be passed into the successive animation players
+ var /** @type {?} */ allQueriedPlayers = [];
+ var /** @type {?} */ allConsumedElements = new Set();
+ var /** @type {?} */ allSubElements = new Set();
+ var /** @type {?} */ allNewPlayers = instruction.timelines.map(function (timelineInstruction) {
+ var /** @type {?} */ element = timelineInstruction.element;
+ allConsumedElements.add(element);
+ // FIXME (matsko): make sure to-be-removed animations are removed properly
+ var /** @type {?} */ details = element[REMOVAL_FLAG];
+ if (details && details.removedBeforeQueried)
+ return new __WEBPACK_IMPORTED_MODULE_1__angular_animations__["NoopAnimationPlayer"]();
+ var /** @type {?} */ isQueriedElement = element !== rootElement;
+ var /** @type {?} */ previousPlayers = (allPreviousPlayersMap.get(element) || EMPTY_PLAYER_ARRAY).map(function (p) { return p.getRealPlayer(); });
+ var /** @type {?} */ preStyles = preStylesMap.get(element);
+ var /** @type {?} */ postStyles = postStylesMap.get(element);
+ var /** @type {?} */ keyframes = normalizeKeyframes(_this.driver, _this._normalizer, element, timelineInstruction.keyframes, preStyles, postStyles);
+ var /** @type {?} */ player = _this._buildPlayer(timelineInstruction, keyframes, previousPlayers);
+ // this means that this particular player belongs to a sub trigger. It is
+ // important that we match this player up with the corresponding (@trigger.listener)
+ if (timelineInstruction.subTimeline && skippedPlayersMap) {
+ allSubElements.add(element);
+ }
+ if (isQueriedElement) {
+ var /** @type {?} */ wrappedPlayer = new TransitionAnimationPlayer(namespaceId, triggerName, element);
+ wrappedPlayer.setRealPlayer(player);
+ allQueriedPlayers.push(wrappedPlayer);
+ }
+ return player;
+ });
+ allQueriedPlayers.forEach(function (player) {
+ getOrSetAsInMap(_this.playersByQueriedElement, player.element, []).push(player);
+ player.onDone(function () { return deleteOrUnsetInMap(_this.playersByQueriedElement, player.element, player); });
+ });
+ allConsumedElements.forEach(function (element) { return addClass(element, NG_ANIMATING_CLASSNAME); });
+ var /** @type {?} */ player = optimizeGroupPlayer(allNewPlayers);
+ player.onDestroy(function () {
+ allConsumedElements.forEach(function (element) { return removeClass(element, NG_ANIMATING_CLASSNAME); });
+ setStyles(rootElement, instruction.toStyles);
+ });
+ // this basically makes all of the callbacks for sub element animations
+ // be dependent on the upper players for when they finish
+ allSubElements.forEach(function (element) { getOrSetAsInMap(skippedPlayersMap, element, []).push(player); });
+ return player;
+ };
+ /**
+ * @param {?} instruction
+ * @param {?} keyframes
+ * @param {?} previousPlayers
+ * @return {?}
+ */
+ TransitionAnimationEngine.prototype._buildPlayer = function (instruction, keyframes, previousPlayers) {
+ if (keyframes.length > 0) {
+ return this.driver.animate(instruction.element, keyframes, instruction.duration, instruction.delay, instruction.easing, previousPlayers);
+ }
+ // special case for when an empty transition|definition is provided
+ // ... there is no point in rendering an empty animation
+ return new __WEBPACK_IMPORTED_MODULE_1__angular_animations__["NoopAnimationPlayer"]();
+ };
+ return TransitionAnimationEngine;
+}());
+var TransitionAnimationPlayer = (function () {
+ /**
+ * @param {?} namespaceId
+ * @param {?} triggerName
+ * @param {?} element
+ */
+ function TransitionAnimationPlayer(namespaceId, triggerName, element) {
+ this.namespaceId = namespaceId;
+ this.triggerName = triggerName;
+ this.element = element;
+ this._player = new __WEBPACK_IMPORTED_MODULE_1__angular_animations__["NoopAnimationPlayer"]();
+ this._containsRealPlayer = false;
+ this._queuedCallbacks = {};
+ this._destroyed = false;
+ this.markedForDestroy = false;
+ }
+ Object.defineProperty(TransitionAnimationPlayer.prototype, "queued", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this._containsRealPlayer == false; },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(TransitionAnimationPlayer.prototype, "destroyed", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this._destroyed; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} player
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.setRealPlayer = function (player) {
+ var _this = this;
+ if (this._containsRealPlayer)
+ return;
+ this._player = player;
+ Object.keys(this._queuedCallbacks).forEach(function (phase) {
+ _this._queuedCallbacks[phase].forEach(function (callback) { return listenOnPlayer(player, phase, undefined, callback); });
+ });
+ this._queuedCallbacks = {};
+ this._containsRealPlayer = true;
+ };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.getRealPlayer = function () { return this._player; };
+ /**
+ * @param {?} name
+ * @param {?} callback
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype._queueEvent = function (name, callback) {
+ getOrSetAsInMap(this._queuedCallbacks, name, []).push(callback);
+ };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.onDone = function (fn) {
+ if (this.queued) {
+ this._queueEvent('done', fn);
+ }
+ this._player.onDone(fn);
+ };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.onStart = function (fn) {
+ if (this.queued) {
+ this._queueEvent('start', fn);
+ }
+ this._player.onStart(fn);
+ };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.onDestroy = function (fn) {
+ if (this.queued) {
+ this._queueEvent('destroy', fn);
+ }
+ this._player.onDestroy(fn);
+ };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.init = function () { this._player.init(); };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.hasStarted = function () { return this.queued ? false : this._player.hasStarted(); };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.play = function () { !this.queued && this._player.play(); };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.pause = function () { !this.queued && this._player.pause(); };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.restart = function () { !this.queued && this._player.restart(); };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.finish = function () { this._player.finish(); };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.destroy = function () {
+ this._destroyed = true;
+ this._player.destroy();
+ };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.reset = function () { !this.queued && this._player.reset(); };
+ /**
+ * @param {?} p
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.setPosition = function (p) {
+ if (!this.queued) {
+ this._player.setPosition(p);
+ }
+ };
+ /**
+ * @return {?}
+ */
+ TransitionAnimationPlayer.prototype.getPosition = function () { return this.queued ? 0 : this._player.getPosition(); };
+ Object.defineProperty(TransitionAnimationPlayer.prototype, "totalTime", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this._player.totalTime; },
+ enumerable: true,
+ configurable: true
+ });
+ return TransitionAnimationPlayer;
+}());
+/**
+ * @param {?} map
+ * @param {?} key
+ * @param {?} value
+ * @return {?}
+ */
+function deleteOrUnsetInMap(map, key, value) {
+ var /** @type {?} */ currentValues;
+ if (map instanceof Map) {
+ currentValues = map.get(key);
+ if (currentValues) {
+ if (currentValues.length) {
+ var /** @type {?} */ index = currentValues.indexOf(value);
+ currentValues.splice(index, 1);
+ }
+ if (currentValues.length == 0) {
+ map.delete(key);
+ }
+ }
+ }
+ else {
+ currentValues = map[key];
+ if (currentValues) {
+ if (currentValues.length) {
+ var /** @type {?} */ index = currentValues.indexOf(value);
+ currentValues.splice(index, 1);
+ }
+ if (currentValues.length == 0) {
+ delete map[key];
+ }
+ }
+ }
+ return currentValues;
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function normalizeTriggerValue(value) {
+ switch (typeof value) {
+ case 'boolean':
+ return value ? '1' : '0';
+ default:
+ return value != null ? value.toString() : null;
+ }
+}
+/**
+ * @param {?} node
+ * @return {?}
+ */
+function isElementNode(node) {
+ return node && node['nodeType'] === 1;
+}
+/**
+ * @param {?} eventName
+ * @return {?}
+ */
+function isTriggerEventValid(eventName) {
+ return eventName == 'start' || eventName == 'done';
+}
+/**
+ * @param {?} element
+ * @param {?=} value
+ * @return {?}
+ */
+function cloakElement(element, value) {
+ var /** @type {?} */ oldValue = element.style.display;
+ element.style.display = value != null ? value : 'none';
+ return oldValue;
+}
+/**
+ * @param {?} driver
+ * @param {?} elements
+ * @param {?} elementPropsMap
+ * @param {?} defaultStyle
+ * @return {?}
+ */
+function cloakAndComputeStyles(driver, elements, elementPropsMap, defaultStyle) {
+ var /** @type {?} */ cloakVals = elements.map(function (element) { return cloakElement(element); });
+ var /** @type {?} */ valuesMap = new Map();
+ elementPropsMap.forEach(function (props, element) {
+ var /** @type {?} */ styles = {};
+ props.forEach(function (prop) {
+ var /** @type {?} */ value = styles[prop] = driver.computeStyle(element, prop, defaultStyle);
+ // there is no easy way to detect this because a sub element could be removed
+ // by a parent animation element being detached.
+ if (!value || value.length == 0) {
+ element[REMOVAL_FLAG] = NULL_REMOVED_QUERIED_STATE;
+ }
+ });
+ valuesMap.set(element, styles);
+ });
+ elements.forEach(function (element, i) { return cloakElement(element, cloakVals[i]); });
+ return valuesMap;
+}
+/**
+ * @param {?} nodes
+ * @return {?}
+ */
+function createIsRootFilterFn(nodes) {
+ var /** @type {?} */ nodeSet = new Set(nodes);
+ var /** @type {?} */ knownRootContainer = new Set();
+ var /** @type {?} */ isRoot;
+ isRoot = function (node) {
+ if (!node)
+ return true;
+ if (nodeSet.has(node.parentNode))
+ return false;
+ if (knownRootContainer.has(node.parentNode))
+ return true;
+ if (isRoot(node.parentNode)) {
+ knownRootContainer.add(node);
+ return true;
+ }
+ return false;
+ };
+ return isRoot;
+}
+var CLASSES_CACHE_KEY = '$$classes';
+/**
+ * @param {?} element
+ * @param {?} className
+ * @return {?}
+ */
+function containsClass(element, className) {
+ if (element.classList) {
+ return element.classList.contains(className);
+ }
+ else {
+ var /** @type {?} */ classes = element[CLASSES_CACHE_KEY];
+ return classes && classes[className];
+ }
+}
+/**
+ * @param {?} element
+ * @param {?} className
+ * @return {?}
+ */
+function addClass(element, className) {
+ if (element.classList) {
+ element.classList.add(className);
+ }
+ else {
+ var /** @type {?} */ classes = element[CLASSES_CACHE_KEY];
+ if (!classes) {
+ classes = element[CLASSES_CACHE_KEY] = {};
+ }
+ classes[className] = true;
+ }
+}
+/**
+ * @param {?} element
+ * @param {?} className
+ * @return {?}
+ */
+function removeClass(element, className) {
+ if (element.classList) {
+ element.classList.remove(className);
+ }
+ else {
+ var /** @type {?} */ classes = element[CLASSES_CACHE_KEY];
+ if (classes) {
+ delete classes[className];
+ }
+ }
+}
+/**
+ * @return {?}
+ */
+function getBodyNode() {
+ if (typeof document != 'undefined') {
+ return document.body;
+ }
+ return null;
+}
+/**
+ * @param {?} engine
+ * @param {?} element
+ * @param {?} players
+ * @return {?}
+ */
+function removeNodesAfterAnimationDone(engine, element, players) {
+ optimizeGroupPlayer(players).onDone(function () { return engine.processLeaveNode(element); });
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var AnimationEngine = (function () {
+ /**
+ * @param {?} driver
+ * @param {?} normalizer
+ */
+ function AnimationEngine(driver, normalizer) {
+ var _this = this;
+ this._triggerCache = {};
+ this.onRemovalComplete = function (element, context) { };
+ this._transitionEngine = new TransitionAnimationEngine(driver, normalizer);
+ this._timelineEngine = new TimelineAnimationEngine(driver, normalizer);
+ this._transitionEngine.onRemovalComplete =
+ function (element, context) { _this.onRemovalComplete(element, context); };
+ }
+ /**
+ * @param {?} componentId
+ * @param {?} namespaceId
+ * @param {?} hostElement
+ * @param {?} name
+ * @param {?} metadata
+ * @return {?}
+ */
+ AnimationEngine.prototype.registerTrigger = function (componentId, namespaceId, hostElement, name, metadata) {
+ var /** @type {?} */ cacheKey = componentId + '-' + name;
+ var /** @type {?} */ trigger = this._triggerCache[cacheKey];
+ if (!trigger) {
+ var /** @type {?} */ errors = [];
+ var /** @type {?} */ ast = (buildAnimationAst(/** @type {?} */ (metadata), errors));
+ if (errors.length) {
+ throw new Error("The animation trigger \"" + name + "\" has failed to build due to the following errors:\n - " + errors.join("\n - "));
+ }
+ trigger = buildTrigger(name, ast);
+ this._triggerCache[cacheKey] = trigger;
+ }
+ this._transitionEngine.registerTrigger(namespaceId, name, trigger);
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} hostElement
+ * @return {?}
+ */
+ AnimationEngine.prototype.register = function (namespaceId, hostElement) {
+ this._transitionEngine.register(namespaceId, hostElement);
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationEngine.prototype.destroy = function (namespaceId, context) {
+ this._transitionEngine.destroy(namespaceId, context);
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} parent
+ * @param {?} insertBefore
+ * @return {?}
+ */
+ AnimationEngine.prototype.onInsert = function (namespaceId, element, parent, insertBefore) {
+ this._transitionEngine.insertNode(namespaceId, element, parent, insertBefore);
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} context
+ * @return {?}
+ */
+ AnimationEngine.prototype.onRemove = function (namespaceId, element, context) {
+ this._transitionEngine.removeNode(namespaceId, element, context);
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} property
+ * @param {?} value
+ * @return {?}
+ */
+ AnimationEngine.prototype.setProperty = function (namespaceId, element, property, value) {
+ // @@property
+ if (property.charAt(0) == '@') {
+ var _a = parseTimelineCommand(property), id = _a[0], action = _a[1];
+ var /** @type {?} */ args = (value);
+ this._timelineEngine.command(id, element, action, args);
+ return false;
+ }
+ return this._transitionEngine.trigger(namespaceId, element, property, value);
+ };
+ /**
+ * @param {?} namespaceId
+ * @param {?} element
+ * @param {?} eventName
+ * @param {?} eventPhase
+ * @param {?} callback
+ * @return {?}
+ */
+ AnimationEngine.prototype.listen = function (namespaceId, element, eventName, eventPhase, callback) {
+ // @@listen
+ if (eventName.charAt(0) == '@') {
+ var _a = parseTimelineCommand(eventName), id = _a[0], action = _a[1];
+ return this._timelineEngine.listen(id, element, action, callback);
+ }
+ return this._transitionEngine.listen(namespaceId, element, eventName, eventPhase, callback);
+ };
+ /**
+ * @param {?=} microtaskId
+ * @return {?}
+ */
+ AnimationEngine.prototype.flush = function (microtaskId) {
+ if (microtaskId === void 0) { microtaskId = -1; }
+ this._transitionEngine.flush(microtaskId);
+ };
+ Object.defineProperty(AnimationEngine.prototype, "players", {
+ /**
+ * @return {?}
+ */
+ get: function () {
+ return ((this._transitionEngine.players))
+ .concat(/** @type {?} */ (this._timelineEngine.players));
+ },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @return {?}
+ */
+ AnimationEngine.prototype.whenRenderingDone = function () { return this._transitionEngine.whenRenderingDone(); };
+ return AnimationEngine;
+}());
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var WebAnimationsPlayer = (function () {
+ /**
+ * @param {?} element
+ * @param {?} keyframes
+ * @param {?} options
+ * @param {?=} previousPlayers
+ */
+ function WebAnimationsPlayer(element, keyframes, options, previousPlayers) {
+ if (previousPlayers === void 0) { previousPlayers = []; }
+ var _this = this;
+ this.element = element;
+ this.keyframes = keyframes;
+ this.options = options;
+ this.previousPlayers = previousPlayers;
+ this._onDoneFns = [];
+ this._onStartFns = [];
+ this._onDestroyFns = [];
+ this._initialized = false;
+ this._finished = false;
+ this._started = false;
+ this._destroyed = false;
+ this.time = 0;
+ this.parentPlayer = null;
+ this.previousStyles = {};
+ this.currentSnapshot = {};
+ this._duration = options['duration'];
+ this._delay = options['delay'] || 0;
+ this.time = this._duration + this._delay;
+ if (allowPreviousPlayerStylesMerge(this._duration, this._delay)) {
+ previousPlayers.forEach(function (player) {
+ var styles = player.currentSnapshot;
+ Object.keys(styles).forEach(function (prop) { return _this.previousStyles[prop] = styles[prop]; });
+ });
+ }
+ }
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype._onFinish = function () {
+ if (!this._finished) {
+ this._finished = true;
+ this._onDoneFns.forEach(function (fn) { return fn(); });
+ this._onDoneFns = [];
+ }
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.init = function () {
+ this._buildPlayer();
+ this._preparePlayerBeforeStart();
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype._buildPlayer = function () {
+ var _this = this;
+ if (this._initialized)
+ return;
+ this._initialized = true;
+ var /** @type {?} */ keyframes = this.keyframes.map(function (styles) { return copyStyles(styles, false); });
+ var /** @type {?} */ previousStyleProps = Object.keys(this.previousStyles);
+ if (previousStyleProps.length) {
+ var /** @type {?} */ startingKeyframe_1 = keyframes[0];
+ var /** @type {?} */ missingStyleProps_1 = [];
+ previousStyleProps.forEach(function (prop) {
+ if (!startingKeyframe_1.hasOwnProperty(prop)) {
+ missingStyleProps_1.push(prop);
+ }
+ startingKeyframe_1[prop] = _this.previousStyles[prop];
+ });
+ if (missingStyleProps_1.length) {
+ var /** @type {?} */ self_1 = this;
+ var _loop_1 = function () {
+ var /** @type {?} */ kf = keyframes[i];
+ missingStyleProps_1.forEach(function (prop) {
+ kf[prop] = _computeStyle(self_1.element, prop);
+ });
+ };
+ // tslint:disable-next-line
+ for (var /** @type {?} */ i = 1; i < keyframes.length; i++) {
+ _loop_1();
+ }
+ }
+ }
+ this._player = this._triggerWebAnimation(this.element, keyframes, this.options);
+ this._finalKeyframe = keyframes.length ? keyframes[keyframes.length - 1] : {};
+ this._player.addEventListener('finish', function () { return _this._onFinish(); });
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype._preparePlayerBeforeStart = function () {
+ // this is required so that the player doesn't start to animate right away
+ if (this._delay) {
+ this._resetDomPlayerState();
+ }
+ else {
+ this._player.pause();
+ }
+ };
+ /**
+ * \@internal
+ * @param {?} element
+ * @param {?} keyframes
+ * @param {?} options
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype._triggerWebAnimation = function (element, keyframes, options) {
+ // jscompiler doesn't seem to know animate is a native property because it's not fully
+ // supported yet across common browsers (we polyfill it for Edge/Safari) [CL #143630929]
+ return (element['animate'](keyframes, options));
+ };
+ Object.defineProperty(WebAnimationsPlayer.prototype, "domPlayer", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this._player; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.onStart = function (fn) { this._onStartFns.push(fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.onDone = function (fn) { this._onDoneFns.push(fn); };
+ /**
+ * @param {?} fn
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.onDestroy = function (fn) { this._onDestroyFns.push(fn); };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.play = function () {
+ this._buildPlayer();
+ if (!this.hasStarted()) {
+ this._onStartFns.forEach(function (fn) { return fn(); });
+ this._onStartFns = [];
+ this._started = true;
+ }
+ this._player.play();
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.pause = function () {
+ this.init();
+ this._player.pause();
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.finish = function () {
+ this.init();
+ this._onFinish();
+ this._player.finish();
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.reset = function () {
+ this._resetDomPlayerState();
+ this._destroyed = false;
+ this._finished = false;
+ this._started = false;
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype._resetDomPlayerState = function () {
+ if (this._player) {
+ this._player.cancel();
+ }
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.restart = function () {
+ this.reset();
+ this.play();
+ };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.hasStarted = function () { return this._started; };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.destroy = function () {
+ if (!this._destroyed) {
+ this._resetDomPlayerState();
+ this._onFinish();
+ this._destroyed = true;
+ this._onDestroyFns.forEach(function (fn) { return fn(); });
+ this._onDestroyFns = [];
+ }
+ };
+ /**
+ * @param {?} p
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.setPosition = function (p) { this._player.currentTime = p * this.time; };
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.getPosition = function () { return this._player.currentTime / this.time; };
+ Object.defineProperty(WebAnimationsPlayer.prototype, "totalTime", {
+ /**
+ * @return {?}
+ */
+ get: function () { return this._delay + this._duration; },
+ enumerable: true,
+ configurable: true
+ });
+ /**
+ * @return {?}
+ */
+ WebAnimationsPlayer.prototype.beforeDestroy = function () {
+ var _this = this;
+ var /** @type {?} */ styles = {};
+ if (this.hasStarted()) {
+ Object.keys(this._finalKeyframe).forEach(function (prop) {
+ if (prop != 'offset') {
+ styles[prop] =
+ _this._finished ? _this._finalKeyframe[prop] : _computeStyle(_this.element, prop);
+ }
+ });
+ }
+ this.currentSnapshot = styles;
+ };
+ return WebAnimationsPlayer;
+}());
+/**
+ * @param {?} element
+ * @param {?} prop
+ * @return {?}
+ */
+function _computeStyle(element, prop) {
+ return ((window.getComputedStyle(element)))[prop];
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var WebAnimationsDriver = (function () {
+ function WebAnimationsDriver() {
+ }
+ /**
+ * @param {?} element
+ * @param {?} selector
+ * @return {?}
+ */
+ WebAnimationsDriver.prototype.matchesElement = function (element, selector) {
+ return matchesElement(element, selector);
+ };
+ /**
+ * @param {?} elm1
+ * @param {?} elm2
+ * @return {?}
+ */
+ WebAnimationsDriver.prototype.containsElement = function (elm1, elm2) { return containsElement(elm1, elm2); };
+ /**
+ * @param {?} element
+ * @param {?} selector
+ * @param {?} multi
+ * @return {?}
+ */
+ WebAnimationsDriver.prototype.query = function (element, selector, multi) {
+ return invokeQuery(element, selector, multi);
+ };
+ /**
+ * @param {?} element
+ * @param {?} prop
+ * @param {?=} defaultValue
+ * @return {?}
+ */
+ WebAnimationsDriver.prototype.computeStyle = function (element, prop, defaultValue) {
+ return (((window.getComputedStyle(element)))[prop]);
+ };
+ /**
+ * @param {?} element
+ * @param {?} keyframes
+ * @param {?} duration
+ * @param {?} delay
+ * @param {?} easing
+ * @param {?=} previousPlayers
+ * @return {?}
+ */
+ WebAnimationsDriver.prototype.animate = function (element, keyframes, duration, delay, easing, previousPlayers) {
+ if (previousPlayers === void 0) { previousPlayers = []; }
+ var /** @type {?} */ fill = delay == 0 ? 'both' : 'forwards';
+ var /** @type {?} */ playerOptions = { duration: duration, delay: delay, fill: fill };
+ // we check for this to avoid having a null|undefined value be present
+ // for the easing (which results in an error for certain browsers #9752)
+ if (easing) {
+ playerOptions['easing'] = easing;
+ }
+ var /** @type {?} */ previousWebAnimationPlayers = (previousPlayers.filter(function (player) { return player instanceof WebAnimationsPlayer; }));
+ return new WebAnimationsPlayer(element, keyframes, playerOptions, previousWebAnimationPlayers);
+ };
+ return WebAnimationsDriver;
+}());
+/**
+ * @return {?}
+ */
+function supportsWebAnimations() {
+ return typeof Element !== 'undefined' && typeof ((Element)).prototype['animate'] === 'function';
+}
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all animation APIs of the animation browser package.
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of the animation package.
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+//# sourceMappingURL=browser.es5.js.map
+
+
+/***/ }),
+/* 595 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_store__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__devtools__ = __webpack_require__(381);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__config__ = __webpack_require__(380);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__extension__ = __webpack_require__(382);
/* unused harmony export _createReduxDevtoolsExtension */
/* unused harmony export _createState */
/* unused harmony export _createReducer */
@@ -6651,6 +15445,11 @@ exports.compose = function () {
/* unused harmony export noMonitor */
/* unused harmony export _createOptions */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return StoreDevtoolsModule; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_store__ = __webpack_require__(5);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__devtools__ = __webpack_require__(222);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__config__ = __webpack_require__(224);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__extension__ = __webpack_require__(223);
@@ -6675,27 +15474,24 @@ function _createState(devtools) {
function _createReducer(dispatcher, reducer) {
return new __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"](dispatcher, reducer);
}
-function _createStateIfExtension(extension, injector) {
+function _createStateIfExtension(extension, injector, initialState) {
if (!!extension) {
- var devtools = injector.get(__WEBPACK_IMPORTED_MODULE_2__devtools__["a" /* StoreDevtools */]);
+ var devtools = injector.get(__WEBPACK_IMPORTED_MODULE_2__devtools__["b" /* StoreDevtools */]);
return _createState(devtools);
}
else {
- var initialState = injector.get(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_STATE"]);
var dispatcher = injector.get(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Dispatcher"]);
var reducer = injector.get(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"]);
return new __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["State"](initialState, dispatcher, reducer);
}
}
-function _createReducerIfExtension(extension, injector) {
+function _createReducerIfExtension(extension, injector, reducer) {
if (!!extension) {
- var devtoolsDispatcher = injector.get(__WEBPACK_IMPORTED_MODULE_2__devtools__["b" /* DevtoolsDispatcher */]);
- var reducer = injector.get(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_REDUCER"]);
+ var devtoolsDispatcher = injector.get(__WEBPACK_IMPORTED_MODULE_2__devtools__["a" /* DevtoolsDispatcher */]);
return _createReducer(devtoolsDispatcher, reducer);
}
else {
var dispatcher = injector.get(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Dispatcher"]);
- var reducer = injector.get(__WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_REDUCER"]);
return new __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"](dispatcher, reducer);
}
}
@@ -6721,21 +15517,21 @@ var StoreDevtoolsModule = (function () {
providers: [
{
provide: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["State"],
- deps: [__WEBPACK_IMPORTED_MODULE_2__devtools__["a" /* StoreDevtools */]],
+ deps: [__WEBPACK_IMPORTED_MODULE_2__devtools__["b" /* StoreDevtools */]],
useFactory: _createState
},
{
- provide: __WEBPACK_IMPORTED_MODULE_3__config__["b" /* INITIAL_OPTIONS */],
+ provide: __WEBPACK_IMPORTED_MODULE_3__config__["a" /* INITIAL_OPTIONS */],
useValue: _options
},
{
provide: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"],
- deps: [__WEBPACK_IMPORTED_MODULE_2__devtools__["b" /* DevtoolsDispatcher */], __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_REDUCER"]],
+ deps: [__WEBPACK_IMPORTED_MODULE_2__devtools__["a" /* DevtoolsDispatcher */], __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_REDUCER"]],
useFactory: _createReducer
},
{
- provide: __WEBPACK_IMPORTED_MODULE_3__config__["a" /* STORE_DEVTOOLS_CONFIG */],
- deps: [__WEBPACK_IMPORTED_MODULE_3__config__["b" /* INITIAL_OPTIONS */]],
+ provide: __WEBPACK_IMPORTED_MODULE_3__config__["b" /* STORE_DEVTOOLS_CONFIG */],
+ deps: [__WEBPACK_IMPORTED_MODULE_3__config__["a" /* INITIAL_OPTIONS */]],
useFactory: _createOptions
}
]
@@ -6748,59 +15544,60 @@ var StoreDevtoolsModule = (function () {
providers: [
{
provide: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["State"],
- deps: [__WEBPACK_IMPORTED_MODULE_4__extension__["b" /* REDUX_DEVTOOLS_EXTENSION */], __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injector"]],
+ deps: [__WEBPACK_IMPORTED_MODULE_4__extension__["b" /* REDUX_DEVTOOLS_EXTENSION */], __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injector"], __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_STATE"]],
useFactory: _createStateIfExtension
},
{
provide: __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["Reducer"],
- deps: [__WEBPACK_IMPORTED_MODULE_4__extension__["b" /* REDUX_DEVTOOLS_EXTENSION */], __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injector"]],
+ deps: [__WEBPACK_IMPORTED_MODULE_4__extension__["b" /* REDUX_DEVTOOLS_EXTENSION */], __WEBPACK_IMPORTED_MODULE_0__angular_core__["Injector"], __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["INITIAL_REDUCER"]],
useFactory: _createReducerIfExtension
},
{
- provide: __WEBPACK_IMPORTED_MODULE_3__config__["b" /* INITIAL_OPTIONS */],
+ provide: __WEBPACK_IMPORTED_MODULE_3__config__["a" /* INITIAL_OPTIONS */],
useValue: _options
},
{
- provide: __WEBPACK_IMPORTED_MODULE_3__config__["a" /* STORE_DEVTOOLS_CONFIG */],
- deps: [__WEBPACK_IMPORTED_MODULE_3__config__["b" /* INITIAL_OPTIONS */]],
+ provide: __WEBPACK_IMPORTED_MODULE_3__config__["b" /* STORE_DEVTOOLS_CONFIG */],
+ deps: [__WEBPACK_IMPORTED_MODULE_3__config__["a" /* INITIAL_OPTIONS */]],
useFactory: _createOptions
}
]
};
};
- StoreDevtoolsModule.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["NgModule"], args: [{
- imports: [
- __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["StoreModule"]
- ],
- providers: [
- __WEBPACK_IMPORTED_MODULE_4__extension__["a" /* DevtoolsExtension */],
- __WEBPACK_IMPORTED_MODULE_2__devtools__["b" /* DevtoolsDispatcher */],
- __WEBPACK_IMPORTED_MODULE_2__devtools__["a" /* StoreDevtools */],
- {
- provide: __WEBPACK_IMPORTED_MODULE_4__extension__["b" /* REDUX_DEVTOOLS_EXTENSION */],
- useFactory: _createReduxDevtoolsExtension
- }
- ]
- },] },
- ];
- /** @nocollapse */
- StoreDevtoolsModule.ctorParameters = [];
return StoreDevtoolsModule;
}());
+
+StoreDevtoolsModule.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["NgModule"], args: [{
+ imports: [
+ __WEBPACK_IMPORTED_MODULE_1__ngrx_store__["StoreModule"]
+ ],
+ providers: [
+ __WEBPACK_IMPORTED_MODULE_4__extension__["a" /* DevtoolsExtension */],
+ __WEBPACK_IMPORTED_MODULE_2__devtools__["a" /* DevtoolsDispatcher */],
+ __WEBPACK_IMPORTED_MODULE_2__devtools__["b" /* StoreDevtools */],
+ {
+ provide: __WEBPACK_IMPORTED_MODULE_4__extension__["b" /* REDUX_DEVTOOLS_EXTENSION */],
+ useFactory: _createReduxDevtoolsExtension
+ }
+ ]
+ },] },
+];
+/** @nocollapse */
+StoreDevtoolsModule.ctorParameters = function () { return []; };
//# sourceMappingURL=instrument.js.map
/***/ }),
-/* 588 */
+/* 596 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_store__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__utils__ = __webpack_require__(249);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__actions__ = __webpack_require__(248);
/* unused harmony export INIT_ACTION */
/* harmony export (immutable) */ __webpack_exports__["a"] = liftInitialState;
/* harmony export (immutable) */ __webpack_exports__["b"] = liftReducerWith;
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_store__ = __webpack_require__(5);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__utils__ = __webpack_require__(131);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__actions__ = __webpack_require__(132);
@@ -6858,7 +15655,7 @@ function liftInitialState(initialCommittedState, monitorReducer) {
return {
monitorState: monitorReducer(undefined, {}),
nextActionId: 1,
- actionsById: { 0: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["b" /* liftAction */])(INIT_ACTION) },
+ actionsById: { 0: __WEBPACK_IMPORTED_MODULE_1__utils__["c" /* liftAction */](INIT_ACTION) },
stagedActionIds: [0],
skippedActionIds: [],
committedState: initialCommittedState,
@@ -6908,9 +15705,9 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
// value whenever we feel like we don't have to recompute the states.
var minInvalidatedStateIndex = 0;
switch (liftedAction.type) {
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].RESET: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].RESET: {
// Get back to the state the store was created with.
- actionsById = { 0: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["b" /* liftAction */])(INIT_ACTION) };
+ actionsById = { 0: __WEBPACK_IMPORTED_MODULE_1__utils__["c" /* liftAction */](INIT_ACTION) };
nextActionId = 1;
stagedActionIds = [0];
skippedActionIds = [];
@@ -6919,10 +15716,10 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
computedStates = [];
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].COMMIT: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].COMMIT: {
// Consider the last committed state the new starting point.
// Squash any staged actions into a single committed state.
- actionsById = { 0: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["b" /* liftAction */])(INIT_ACTION) };
+ actionsById = { 0: __WEBPACK_IMPORTED_MODULE_1__utils__["c" /* liftAction */](INIT_ACTION) };
nextActionId = 1;
stagedActionIds = [0];
skippedActionIds = [];
@@ -6931,10 +15728,10 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
computedStates = [];
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].ROLLBACK: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].ROLLBACK: {
// Forget about any staged actions.
// Start again from the last committed state.
- actionsById = { 0: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["b" /* liftAction */])(INIT_ACTION) };
+ actionsById = { 0: __WEBPACK_IMPORTED_MODULE_1__utils__["c" /* liftAction */](INIT_ACTION) };
nextActionId = 1;
stagedActionIds = [0];
skippedActionIds = [];
@@ -6942,7 +15739,7 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
computedStates = [];
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].TOGGLE_ACTION: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].TOGGLE_ACTION: {
// Toggle whether an action with given ID is skipped.
// Being skipped means it is a no-op during the computation.
var actionId_1 = liftedAction.id;
@@ -6957,7 +15754,7 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
minInvalidatedStateIndex = stagedActionIds.indexOf(actionId_1);
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].SET_ACTIONS_ACTIVE: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].SET_ACTIONS_ACTIVE: {
// Toggle whether an action with given ID is skipped.
// Being skipped means it is a no-op during the computation.
var start = liftedAction.start, end = liftedAction.end, active = liftedAction.active;
@@ -6965,7 +15762,7 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
for (var i = start; i < end; i++)
actionIds.push(i);
if (active) {
- skippedActionIds = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["d" /* difference */])(skippedActionIds, actionIds);
+ skippedActionIds = __WEBPACK_IMPORTED_MODULE_1__utils__["b" /* difference */](skippedActionIds, actionIds);
}
else {
skippedActionIds = skippedActionIds.concat(actionIds);
@@ -6974,7 +15771,7 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
minInvalidatedStateIndex = stagedActionIds.indexOf(start);
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].JUMP_TO_STATE: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].JUMP_TO_STATE: {
// Without recomputing anything, move the pointer that tell us
// which state is considered the current one. Useful for sliders.
currentStateIndex = liftedAction.index;
@@ -6982,14 +15779,14 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
minInvalidatedStateIndex = Infinity;
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].SWEEP: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].SWEEP: {
// Forget any actions that are currently being skipped.
- stagedActionIds = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__utils__["d" /* difference */])(stagedActionIds, skippedActionIds);
+ stagedActionIds = __WEBPACK_IMPORTED_MODULE_1__utils__["b" /* difference */](stagedActionIds, skippedActionIds);
skippedActionIds = [];
currentStateIndex = Math.min(currentStateIndex, stagedActionIds.length - 1);
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].PERFORM_ACTION: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].PERFORM_ACTION: {
// Auto-commit as new actions come in.
if (options.maxAge && stagedActionIds.length === options.maxAge) {
commitExcessActions(1);
@@ -7006,9 +15803,9 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
minInvalidatedStateIndex = stagedActionIds.length - 1;
break;
}
- case __WEBPACK_IMPORTED_MODULE_2__actions__["b" /* ActionTypes */].IMPORT_STATE: {
+ case __WEBPACK_IMPORTED_MODULE_2__actions__["a" /* ActionTypes */].IMPORT_STATE: {
// Completely replace everything.
- (_b = liftedAction.nextLiftedState, monitorState = _b.monitorState, actionsById = _b.actionsById, nextActionId = _b.nextActionId, stagedActionIds = _b.stagedActionIds, skippedActionIds = _b.skippedActionIds, committedState = _b.committedState, currentStateIndex = _b.currentStateIndex, computedStates = _b.computedStates, _b);
+ (_b = liftedAction.nextLiftedState, monitorState = _b.monitorState, actionsById = _b.actionsById, nextActionId = _b.nextActionId, stagedActionIds = _b.stagedActionIds, skippedActionIds = _b.skippedActionIds, committedState = _b.committedState, currentStateIndex = _b.currentStateIndex, computedStates = _b.computedStates);
break;
}
case __WEBPACK_IMPORTED_MODULE_0__ngrx_store__["Reducer"].REPLACE:
@@ -7049,18 +15846,18 @@ function liftReducerWith(initialCommittedState, initialLiftedState, monitorReduc
//# sourceMappingURL=reducer.js.map
/***/ }),
-/* 589 */
+/* 597 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_common__ = __webpack_require__(43);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__src_dock_monitor_index__ = __webpack_require__(383);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__src_log_monitor_index__ = __webpack_require__(598);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__src_store_log_monitor__ = __webpack_require__(602);
-/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "useLogMonitor", function() { return __WEBPACK_IMPORTED_MODULE_2__src_dock_monitor_index__["b"]; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StoreLogMonitorModule", function() { return StoreLogMonitorModule; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_common__ = __webpack_require__(26);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__src_dock_monitor_index__ = __webpack_require__(225);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__src_log_monitor_index__ = __webpack_require__(603);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__src_store_log_monitor__ = __webpack_require__(611);
+/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "useLogMonitor", function() { return __WEBPACK_IMPORTED_MODULE_2__src_dock_monitor_index__["b"]; });
@@ -7092,17 +15889,17 @@ var StoreLogMonitorModule = (function () {
//# sourceMappingURL=index.js.map
/***/ }),
-/* 590 */
+/* 598 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_operator_filter__ = __webpack_require__(93);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_operator_filter___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_rxjs_operator_filter__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_operator_map__ = __webpack_require__(23);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_operator_map__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__keycodes__ = __webpack_require__(593);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return CommanderComponent; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_operator_filter__ = __webpack_require__(45);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rxjs_operator_filter___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_rxjs_operator_filter__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_operator_map__ = __webpack_require__(16);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_rxjs_operator_map__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__keycodes__ = __webpack_require__(599);
@@ -7186,66 +15983,63 @@ var CommanderComponent = (function () {
//# sourceMappingURL=commander.js.map
/***/ }),
-/* 591 */
+/* 599 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__ = __webpack_require__(246);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__ngrx_store_devtools__ = __webpack_require__(247);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge__ = __webpack_require__(181);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__ = __webpack_require__(23);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__actions__ = __webpack_require__(250);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DockMonitorComponent; });
-
-
-
-
-
-
-var DockMonitorComponent = (function () {
- function DockMonitorComponent(tools, actions) {
- this.state$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(tools.liftedState, function (s) { return s.monitorState; });
- this.visible$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(this.state$, function (s) { return s.visible; });
- this.position$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(this.state$, function (s) { return s.position; });
- this.size$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(this.state$, function (s) { return s.size; });
- this.toggle$ = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["EventEmitter"]();
- this.changePosition$ = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["EventEmitter"]();
- this.actionsSubscription = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge__["merge"])(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__["map"].call(this.toggle$, function () { return actions.toggleVisibility(); }), __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__["map"].call(this.changePosition$, function () { return actions.changePosition(); })).subscribe(tools);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return KEYCODES; });
+// Most of these are according to this table: http://www.ssicom.org/js/x171166.htm
+// However where nodejs readline diverges, they are adjusted to conform to it
+var KEYCODES = {
+ nomod: {
+ escape: '\u001b',
+ space: ' ' // actually '\u0020'
+ },
+ ctrl: {
+ ' ': '\u0000',
+ 'a': '\u0001',
+ 'b': '\u0002',
+ 'c': '\u0003',
+ 'd': '\u0004',
+ 'e': '\u0005',
+ 'f': '\u0006',
+ 'g': '\u0007',
+ 'h': '\u0008',
+ 'i': '\u0009',
+ 'j': '\u000a',
+ 'k': '\u000b',
+ 'm': '\u000c',
+ 'n': '\u000d',
+ 'l': '\u000e',
+ 'o': '\u000f',
+ 'p': '\u0010',
+ 'q': '\u0011',
+ 'r': '\u0012',
+ 's': '\u0013',
+ 't': '\u0014',
+ 'u': '\u0015',
+ 'v': '\u0016',
+ 'w': '\u0017',
+ 'x': '\u0018',
+ 'y': '\u0019',
+ 'z': '\u001a',
+ '[': '\u001b',
+ '\\': '\u001c',
+ ']': '\u001d',
+ '^': '\u001e',
+ '_': '\u001f',
+ 'space': '\u0000'
}
- DockMonitorComponent.prototype.ngOnDestroy = function () {
- this.actionsSubscription.unsubscribe();
- };
- DockMonitorComponent.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Component"], args: [{
- selector: 'dock-monitor',
- changeDetection: __WEBPACK_IMPORTED_MODULE_0__angular_core__["ChangeDetectionStrategy"].OnPush,
- template: "\n \n \n\n \n \n \n "
- },] },
- ];
- /** @nocollapse */
- DockMonitorComponent.ctorParameters = [
- { type: __WEBPACK_IMPORTED_MODULE_2__ngrx_store_devtools__["StoreDevtools"], },
- { type: __WEBPACK_IMPORTED_MODULE_5__actions__["a" /* DockActions */], },
- ];
- DockMonitorComponent.propDecorators = {
- 'toggleCommand': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Input"] },],
- 'positionCommand': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Input"] },],
- };
- return DockMonitorComponent;
-}());
-//# sourceMappingURL=dock-monitor.js.map
+};
+//# sourceMappingURL=keycodes.js.map
/***/ }),
-/* 592 */
+/* 600 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DockComponent; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
var DockComponent = (function () {
function DockComponent() {
@@ -7338,65 +16132,68 @@ var DockComponent = (function () {
//# sourceMappingURL=dock.js.map
/***/ }),
-/* 593 */
+/* 601 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return KEYCODES; });
-// Most of these are according to this table: http://www.ssicom.org/js/x171166.htm
-// However where nodejs readline diverges, they are adjusted to conform to it
-var KEYCODES = {
- nomod: {
- escape: '\u001b',
- space: ' ' // actually '\u0020'
- },
- ctrl: {
- ' ': '\u0000',
- 'a': '\u0001',
- 'b': '\u0002',
- 'c': '\u0003',
- 'd': '\u0004',
- 'e': '\u0005',
- 'f': '\u0006',
- 'g': '\u0007',
- 'h': '\u0008',
- 'i': '\u0009',
- 'j': '\u000a',
- 'k': '\u000b',
- 'm': '\u000c',
- 'n': '\u000d',
- 'l': '\u000e',
- 'o': '\u000f',
- 'p': '\u0010',
- 'q': '\u0011',
- 'r': '\u0012',
- 's': '\u0013',
- 't': '\u0014',
- 'u': '\u0015',
- 'v': '\u0016',
- 'w': '\u0017',
- 'x': '\u0018',
- 'y': '\u0019',
- 'z': '\u001a',
- '[': '\u001b',
- '\\': '\u001c',
- ']': '\u001d',
- '^': '\u001e',
- '_': '\u001f',
- 'space': '\u0000'
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DockMonitorComponent; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(1);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__ = __webpack_require__(133);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__ngrx_store_devtools__ = __webpack_require__(130);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge__ = __webpack_require__(63);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__ = __webpack_require__(16);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__actions__ = __webpack_require__(134);
+
+
+
+
+
+
+var DockMonitorComponent = (function () {
+ function DockMonitorComponent(tools, actions) {
+ this.state$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(tools.liftedState, function (s) { return s.monitorState; });
+ this.visible$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(this.state$, function (s) { return s.visible; });
+ this.position$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(this.state$, function (s) { return s.position; });
+ this.size$ = __WEBPACK_IMPORTED_MODULE_1__ngrx_core_operator_select__["select"].call(this.state$, function (s) { return s.size; });
+ this.toggle$ = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["EventEmitter"]();
+ this.changePosition$ = new __WEBPACK_IMPORTED_MODULE_0__angular_core__["EventEmitter"]();
+ this.actionsSubscription = __WEBPACK_IMPORTED_MODULE_3_rxjs_observable_merge__["merge"](__WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__["map"].call(this.toggle$, function () { return actions.toggleVisibility(); }), __WEBPACK_IMPORTED_MODULE_4_rxjs_operator_map__["map"].call(this.changePosition$, function () { return actions.changePosition(); })).subscribe(tools);
}
-};
-//# sourceMappingURL=keycodes.js.map
+ DockMonitorComponent.prototype.ngOnDestroy = function () {
+ this.actionsSubscription.unsubscribe();
+ };
+ DockMonitorComponent.decorators = [
+ { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Component"], args: [{
+ selector: 'dock-monitor',
+ changeDetection: __WEBPACK_IMPORTED_MODULE_0__angular_core__["ChangeDetectionStrategy"].OnPush,
+ template: "\n \n \n\n \n \n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ DockMonitorComponent.ctorParameters = [
+ { type: __WEBPACK_IMPORTED_MODULE_2__ngrx_store_devtools__["StoreDevtools"], },
+ { type: __WEBPACK_IMPORTED_MODULE_5__actions__["a" /* DockActions */], },
+ ];
+ DockMonitorComponent.propDecorators = {
+ 'toggleCommand': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Input"] },],
+ 'positionCommand': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Input"] },],
+ };
+ return DockMonitorComponent;
+}());
+//# sourceMappingURL=dock-monitor.js.map
/***/ }),
-/* 594 */
+/* 602 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_store__ = __webpack_require__(9);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__actions__ = __webpack_require__(250);
/* unused harmony export POSITIONS */
/* harmony export (immutable) */ __webpack_exports__["a"] = useDockMonitor;
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ngrx_store__ = __webpack_require__(5);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__actions__ = __webpack_require__(134);
var POSITIONS = ['left', 'top', 'right', 'bottom'];
@@ -7425,7 +16222,7 @@ function useDockMonitor(_options) {
!state :
state;
}
- return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0__ngrx_store__["combineReducers"])({
+ return __WEBPACK_IMPORTED_MODULE_0__ngrx_store__["combineReducers"]({
position: position,
visible: visible,
size: size
@@ -7434,143 +16231,17 @@ function useDockMonitor(_options) {
//# sourceMappingURL=reducer.js.map
/***/ }),
-/* 595 */
+/* 603 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_common__ = __webpack_require__(43);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__json_node__ = __webpack_require__(596);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__json_tree__ = __webpack_require__(597);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return JsonTreeModule; });
-
-
-
-
-var JsonTreeModule = (function () {
- function JsonTreeModule() {
- }
- JsonTreeModule.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["NgModule"], args: [{
- imports: [
- __WEBPACK_IMPORTED_MODULE_1__angular_common__["CommonModule"]
- ],
- declarations: [
- __WEBPACK_IMPORTED_MODULE_2__json_node__["a" /* JsonNodeComponent */],
- __WEBPACK_IMPORTED_MODULE_3__json_tree__["a" /* JsonTreeComponent */]
- ],
- exports: [
- __WEBPACK_IMPORTED_MODULE_3__json_tree__["a" /* JsonTreeComponent */]
- ]
- },] },
- ];
- /** @nocollapse */
- JsonTreeModule.ctorParameters = [];
- return JsonTreeModule;
-}());
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-/* 596 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(0);
-/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__types__ = __webpack_require__(384);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return JsonNodeComponent; });
-
-
-var JsonNodeComponent = (function () {
- function JsonNodeComponent() {
- this.expanded = false;
- }
- Object.defineProperty(JsonNodeComponent.prototype, "value", {
- set: function (value) {
- this.label = __WEBPACK_IMPORTED_MODULE_1__types__["b" /* getLabelFor */](value);
- this.type = __WEBPACK_IMPORTED_MODULE_1__types__["c" /* getTypeOf */](value);
- if (this.type === __WEBPACK_IMPORTED_MODULE_1__types__["d" /* KNOWN */].Array || this.type === __WEBPACK_IMPORTED_MODULE_1__types__["d" /* KNOWN */].Object || this.type === __WEBPACK_IMPORTED_MODULE_1__types__["d" /* KNOWN */].Iterable) {
- this.children = __WEBPACK_IMPORTED_MODULE_1__types__["a" /* getChildrenFor */](value);
- }
- else {
- this.children = null;
- }
- },
- enumerable: true,
- configurable: true
- });
- JsonNodeComponent.prototype.toggle = function () {
- if (this.children) {
- this.expanded = !this.expanded;
- }
- };
- JsonNodeComponent.decorators = [
- { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__["Component"], args: [{
- selector: 'ngrx-json-node',
- styles: ["\n :host {\n display: block;\n padding: 2px 2px 2px 20px;\n position: relative;\n color: #70AFCD;\n font-family: 'monaco', 'Consolas', 'Lucida Console', monospace;\n }\n .expanded-indicator {\n position: absolute;\n top: 7px;\n left: 5px;\n font-size: 10px;\n transition: transform 200ms;\n }\n\n .expanded .expanded-indicator {\n transform: rotate(90deg);\n }\n\n .node-key::after {\n content: ': ';\n display: inline;\n }\n\n .expanded .node-label {\n color: #BABBBD !important;\n }\n\n .node-label {\n color: #9AC05C;\n }\n\n .node-label.array, .node-label.null, .node-label.iterable {\n color: #D182C0;\n }\n\n .node-label.number, .node-label.undefined, .node-label.boolean {\n color: #F86936;\n }\n "],
- template: "\n
\r\n \r\n When a key is configured as layer switcher key, you can't assign other functions to it.\r\n To assign a scancode to the key, set the Layer action to None.\r\n
";
+module.exports = "
\r\n
\r\n
\r\n
Enter delay in seconds
\r\n
\r\n
\r\n
\r\n
\r\n \r\n
\r\n
\r\n
\r\n
\r\n
Choose a preset
\r\n \r\n
\r\n
\r\n
\r\n";
/***/ }),
-/* 690 */
+/* 675 */
/***/ (function(module, exports) {
-module.exports = "\r\n \r\n the\r\n \r\n \r\n layer by pressing this key.\r\n layer by holding this key.\r\n \r\n\r\n\r\n Layer switching is only possible from the base layer. \r\n";
+module.exports = ":host {\n display: flex;\n flex-direction: column;\n position: relative; }\n\n.macro-delay__presets {\n margin-top: 1rem; }\n .macro-delay__presets button {\n margin-right: 0.25rem;\n margin-bottom: 0.25rem; }\n"
/***/ }),
-/* 691 */
+/* 676 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var macro_key_component_1 = __webpack_require__(677);
+exports.MacroKeyTabComponent = macro_key_component_1.MacroKeyTabComponent;
+
+
+/***/ }),
+/* 677 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var key_action_1 = __webpack_require__(14);
+var macro_action_1 = __webpack_require__(39);
+var tab_1 = __webpack_require__(100);
+var tab_2 = __webpack_require__(100);
+var TabName;
+(function (TabName) {
+ TabName[TabName["Keypress"] = 0] = "Keypress";
+ TabName[TabName["Hold"] = 1] = "Hold";
+ TabName[TabName["Release"] = 2] = "Release";
+})(TabName || (TabName = {}));
+var MacroKeyTabComponent = (function () {
+ function MacroKeyTabComponent() {
+ /* tslint:disable:variable-name: It is an enum type. So it can start with uppercase. */
+ this.TabName = TabName;
+ }
+ MacroKeyTabComponent.prototype.ngOnInit = function () {
+ if (!this.macroAction) {
+ this.macroAction = new macro_action_1.KeyMacroAction();
+ }
+ this.defaultKeyAction = new key_action_1.KeystrokeAction(this.macroAction);
+ this.selectTab(this.getTabName(this.macroAction));
+ };
+ MacroKeyTabComponent.prototype.selectTab = function (tab) {
+ this.activeTab = tab;
+ };
+ MacroKeyTabComponent.prototype.getTabName = function (macroAction) {
+ if (!macroAction.action) {
+ return TabName.Keypress;
+ }
+ else if (macroAction.action === macro_action_1.MacroSubAction.hold) {
+ return TabName.Hold;
+ }
+ else if (macroAction.action === macro_action_1.MacroSubAction.release) {
+ return TabName.Release;
+ }
+ };
+ MacroKeyTabComponent.prototype.getActionType = function (tab) {
+ switch (tab) {
+ case TabName.Keypress:
+ return macro_action_1.MacroSubAction.press;
+ case TabName.Hold:
+ return macro_action_1.MacroSubAction.hold;
+ case TabName.Release:
+ return macro_action_1.MacroSubAction.release;
+ default:
+ throw new Error('Invalid tab type');
+ }
+ };
+ MacroKeyTabComponent.prototype.getKeyMacroAction = function () {
+ var keyMacroAction = Object.assign(new macro_action_1.KeyMacroAction(), this.keypressTab.toKeyAction());
+ keyMacroAction.action = this.getActionType(this.activeTab);
+ return keyMacroAction;
+ };
+ return MacroKeyTabComponent;
+}());
+__decorate([
+ core_1.Input(),
+ __metadata("design:type", macro_action_1.KeyMacroAction)
+], MacroKeyTabComponent.prototype, "macroAction", void 0);
+__decorate([
+ core_1.ViewChild('tab'),
+ __metadata("design:type", tab_2.Tab)
+], MacroKeyTabComponent.prototype, "selectedTab", void 0);
+__decorate([
+ core_1.ViewChild('keypressTab'),
+ __metadata("design:type", tab_1.KeypressTabComponent)
+], MacroKeyTabComponent.prototype, "keypressTab", void 0);
+MacroKeyTabComponent = __decorate([
+ core_1.Component({
+ selector: 'macro-key-tab',
+ template: __webpack_require__(704),
+ styles: [
+ __webpack_require__(141),
+ __webpack_require__(705)
+ ],
+ host: { 'class': 'macro__mouse' }
+ })
+], MacroKeyTabComponent);
+exports.MacroKeyTabComponent = MacroKeyTabComponent;
+
+
+/***/ }),
+/* 678 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(679));
+
+
+/***/ }),
+/* 679 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+ var extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return function (d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = __webpack_require__(1);
+var key_action_1 = __webpack_require__(14);
+var tab_1 = __webpack_require__(40);
+var KeymapTabComponent = (function (_super) {
+ __extends(KeymapTabComponent, _super);
+ function KeymapTabComponent() {
+ var _this = _super.call(this) || this;
+ _this.keymapOptions = [];
+ return _this;
+ }
+ KeymapTabComponent.prototype.ngOnInit = function () {
+ this.keymapOptions = this.keymaps
+ .map(function (keymap) {
+ return {
+ id: keymap.abbreviation,
+ text: keymap.name
+ };
+ });
+ if (this.keymaps.length > 0) {
+ this.selectedKeymap = this.keymaps[0];
+ }
+ };
+ KeymapTabComponent.prototype.ngOnChanges = function () {
+ this.fromKeyAction(this.defaultKeyAction);
+ this.validAction.emit(true);
+ };
+ // TODO: change to the correct type when the wrapper has added it.
+ KeymapTabComponent.prototype.onChange = function (event) {
+ if (event.value === '-1') {
+ this.selectedKeymap = undefined;
+ }
+ else {
+ this.selectedKeymap = this.keymaps.find(function (keymap) { return keymap.abbreviation === event.value; });
+ }
+ };
+ KeymapTabComponent.prototype.keyActionValid = function () {
+ return !!this.selectedKeymap;
+ };
+ KeymapTabComponent.prototype.fromKeyAction = function (keyAction) {
+ if (!(keyAction instanceof key_action_1.SwitchKeymapAction)) {
+ return false;
+ }
+ var switchKeymapAction = keyAction;
+ this.selectedKeymap = this.keymaps
+ .find(function (keymap) { return keymap.abbreviation === switchKeymapAction.keymapAbbreviation; });
+ };
+ KeymapTabComponent.prototype.toKeyAction = function () {
+ if (!this.keyActionValid()) {
+ throw new Error('KeyAction is not valid. No selected keymap!');
+ }
+ var keymapAction = new key_action_1.SwitchKeymapAction();
+ keymapAction.keymapAbbreviation = this.selectedKeymap.abbreviation;
+ return keymapAction;
+ };
+ return KeymapTabComponent;
+}(tab_1.Tab));
+__decorate([
+ core_1.Input(),
+ __metadata("design:type", key_action_1.KeyAction)
+], KeymapTabComponent.prototype, "defaultKeyAction", void 0);
+__decorate([
+ core_1.Input(),
+ __metadata("design:type", Array)
+], KeymapTabComponent.prototype, "keymaps", void 0);
+KeymapTabComponent = __decorate([
+ core_1.Component({
+ selector: 'keymap-tab',
+ template: __webpack_require__(680),
+ styles: [__webpack_require__(681)],
+ changeDetection: core_1.ChangeDetectionStrategy.OnPush
+ }),
+ __metadata("design:paramtypes", [])
+], KeymapTabComponent);
+exports.KeymapTabComponent = KeymapTabComponent;
+
+
+/***/ }),
+/* 680 */
/***/ (function(module, exports) {
-module.exports = "\r\n No macros are available to choose from. Create a macro first! \r\n\r\n 0\">\r\n
\r\n Play macro: \r\n \r\n
\r\n
\r\n
\r\n \r\n \r\n
\r\n
\r\n";
+module.exports = "\r\n No keymaps are available to choose from. Create a keymap first! \r\n\r\n 0\">\r\n
\r\n \r\n When a key is configured as layer switcher key, you can't assign other functions to it.\r\n To assign a scancode to the key, set the Layer action to None.\r\n
\\r\\n\\r\\n\";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./shared/src/components/popover/popover.component.html\n// module id = 687\n// module chunks = 1","module.exports = \"\\r\\n No keymaps are available to choose from. Create a keymap first! \\r\\n\\r\\n 0\\\">\\r\\n
\\r\\n \\r\\n When a key is configured as layer switcher key, you can't assign other functions to it.\\r\\n To assign a scancode to the key, set the Layer action to None.\\r\\n
\";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./shared/src/components/popover/tab/keypress/keypress-tab.component.html\n// module id = 689\n// module chunks = 1","module.exports = \"\\r\\n \\r\\n the\\r\\n \\r\\n \\r\\n layer by pressing this key.\\r\\n layer by holding this key.\\r\\n \\r\\n\\r\\n\\r\\n Layer switching is only possible from the base layer. \\r\\n\";\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./shared/src/components/popover/tab/layer/layer-tab.component.html\n// module id = 690\n// module chunks = 1","module.exports = \"\\r\\n No macros are available to choose from. Create a macro first! \\r\\n\\r\\n 0\\\">\\r\\n
![](\"./images/base-layer--blank.svg\")
\r\n ![](\\\"./images/base-layer--blank.svg\\\")
\\r\\n