You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6735 lines
237 KiB
6735 lines
237 KiB
2 years ago
|
/******/ (() => { // webpackBootstrap
|
||
|
|
/******/ var __webpack_modules__ = ({
|
||
|
|
|
||
|
|
/***/ "./node_modules/@tiny-components/raw/src/raw.riot":
|
||
|
|
/*!********************************************************!*\
|
||
|
|
!*** ./node_modules/@tiny-components/raw/src/raw.riot ***!
|
||
|
|
\********************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
|
||
|
|
css: null,
|
||
|
|
|
||
|
|
exports: {
|
||
|
|
setInnerHTML() {
|
||
|
|
this.root.innerHTML = this.props.html
|
||
|
|
},
|
||
|
|
|
||
|
|
onMounted() {
|
||
|
|
this.setInnerHTML()
|
||
|
|
},
|
||
|
|
|
||
|
|
onUpdated() {
|
||
|
|
this.setInnerHTML()
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
template: (
|
||
|
|
template,
|
||
|
|
expressionTypes,
|
||
|
|
bindingTypes,
|
||
|
|
getComponent
|
||
|
|
) => template(
|
||
|
|
'\n\n /**\n * tiny raw\n *\n * @author Björn Hase\n * @license http://opensource.org/licenses/MIT The MIT License\n * @link https://gitea.node001.net/tiny-components/raw\n *\n */\n\n ',
|
||
|
|
[]
|
||
|
|
),
|
||
|
|
|
||
|
|
name: 'tiny-raw'
|
||
|
|
});
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./src/slider.riot":
|
||
|
|
/*!*************************!*\
|
||
|
|
!*** ./src/slider.riot ***!
|
||
|
|
\*************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var riot__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! riot */ "./node_modules/riot/esm/api/register.js");
|
||
|
|
/* harmony import */ var _mixin_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./mixin.js */ "./src/mixin.js");
|
||
|
|
/* harmony import */ var _tiny_components_raw_src_raw_riot__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @tiny-components/raw/src/raw.riot */ "./node_modules/@tiny-components/raw/src/raw.riot");
|
||
|
|
// riot
|
||
|
|
|
||
|
|
|
||
|
|
// mixin
|
||
|
|
|
||
|
|
|
||
|
|
// tiny-raw & riot
|
||
|
|
|
||
|
|
riot__WEBPACK_IMPORTED_MODULE_2__.register('tiny-raw', _tiny_components_raw_src_raw_riot__WEBPACK_IMPORTED_MODULE_1__["default"])
|
||
|
|
|
||
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
|
||
|
|
css: null,
|
||
|
|
|
||
|
|
exports: () => {
|
||
|
|
return {
|
||
|
|
|
||
|
|
..._mixin_js__WEBPACK_IMPORTED_MODULE_0__["default"]
|
||
|
|
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
template: (
|
||
|
|
template,
|
||
|
|
expressionTypes,
|
||
|
|
bindingTypes,
|
||
|
|
getComponent
|
||
|
|
) => template(
|
||
|
|
'<div class="slider tiny-slider"><div class="display-flex"><button expr0="expr0"><svg class="icon"><use xlink:href="/symbol-defs.svg#icon-previous"/></svg></button><div class="overflow-hidden"><div expr1="expr1" class="slider__inner tiny-slider__inner"><div expr2="expr2" class="slider__item tiny-slider__item"></div></div></div><button expr7="expr7"><svg class="icon"><use xlink:href="/symbol-defs.svg#icon-next"/></svg></button></div><div class="tiny-slider__select display-flex m-top-4"><span expr8="expr8"></span></div></div>',
|
||
|
|
[
|
||
|
|
{
|
||
|
|
redundantAttribute: 'expr0',
|
||
|
|
selector: '[expr0]',
|
||
|
|
|
||
|
|
expressions: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'class',
|
||
|
|
evaluate: _scope => _scope.getPreviousClasses()
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: expressionTypes.EVENT,
|
||
|
|
name: 'onclick',
|
||
|
|
evaluate: _scope => (event) => { _scope.handlePrevious(event) }
|
||
|
|
}
|
||
|
|
]
|
||
|
|
},
|
||
|
|
{
|
||
|
|
redundantAttribute: 'expr1',
|
||
|
|
selector: '[expr1]',
|
||
|
|
|
||
|
|
expressions: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'style',
|
||
|
|
evaluate: _scope => _scope.getContentStyles()
|
||
|
|
}
|
||
|
|
]
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: bindingTypes.EACH,
|
||
|
|
getKey: null,
|
||
|
|
condition: null,
|
||
|
|
|
||
|
|
template: template(
|
||
|
|
'<h3 expr3="expr3" class="tiny-slider__title"> </h3><figure expr4="expr4" class="tiny-slider__figure"></figure><div class="tiny-slider__content"><div class="content"><tiny-raw expr6="expr6"></tiny-raw></div></div>',
|
||
|
|
[
|
||
|
|
{
|
||
|
|
redundantAttribute: 'expr3',
|
||
|
|
selector: '[expr3]',
|
||
|
|
|
||
|
|
expressions: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.TEXT,
|
||
|
|
childNodeIndex: 0,
|
||
|
|
|
||
|
|
evaluate: _scope => [
|
||
|
|
_scope.slide.title
|
||
|
|
].join(
|
||
|
|
''
|
||
|
|
)
|
||
|
|
}
|
||
|
|
]
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: bindingTypes.IF,
|
||
|
|
evaluate: _scope => _scope.slide.media,
|
||
|
|
redundantAttribute: 'expr4',
|
||
|
|
selector: '[expr4]',
|
||
|
|
|
||
|
|
template: template(
|
||
|
|
'<img expr5="expr5" class="tiny-slider__media" loading="lazy"/>',
|
||
|
|
[
|
||
|
|
{
|
||
|
|
redundantAttribute: 'expr5',
|
||
|
|
selector: '[expr5]',
|
||
|
|
|
||
|
|
expressions: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'src',
|
||
|
|
evaluate: _scope => _scope.slide.media.url
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'alt',
|
||
|
|
evaluate: _scope => _scope.slide.media.description
|
||
|
|
}
|
||
|
|
]
|
||
|
|
}
|
||
|
|
]
|
||
|
|
)
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: bindingTypes.TAG,
|
||
|
|
getComponent: getComponent,
|
||
|
|
evaluate: _scope => 'tiny-raw',
|
||
|
|
slots: [],
|
||
|
|
|
||
|
|
attributes: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'html',
|
||
|
|
evaluate: _scope => _scope.slide.content
|
||
|
|
}
|
||
|
|
],
|
||
|
|
|
||
|
|
redundantAttribute: 'expr6',
|
||
|
|
selector: '[expr6]'
|
||
|
|
}
|
||
|
|
]
|
||
|
|
),
|
||
|
|
|
||
|
|
redundantAttribute: 'expr2',
|
||
|
|
selector: '[expr2]',
|
||
|
|
itemName: 'slide',
|
||
|
|
indexName: null,
|
||
|
|
evaluate: _scope => _scope.props.slides
|
||
|
|
},
|
||
|
|
{
|
||
|
|
redundantAttribute: 'expr7',
|
||
|
|
selector: '[expr7]',
|
||
|
|
|
||
|
|
expressions: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'class',
|
||
|
|
evaluate: _scope => _scope.getNextClasses()
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: expressionTypes.EVENT,
|
||
|
|
name: 'onclick',
|
||
|
|
evaluate: _scope => (event) => { _scope.handleNext(event) }
|
||
|
|
}
|
||
|
|
]
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: bindingTypes.EACH,
|
||
|
|
getKey: null,
|
||
|
|
condition: null,
|
||
|
|
|
||
|
|
template: template(
|
||
|
|
null,
|
||
|
|
[
|
||
|
|
{
|
||
|
|
expressions: [
|
||
|
|
{
|
||
|
|
type: expressionTypes.ATTRIBUTE,
|
||
|
|
name: 'class',
|
||
|
|
evaluate: _scope => _scope.getSelectClasses(_scope.position)
|
||
|
|
},
|
||
|
|
{
|
||
|
|
type: expressionTypes.EVENT,
|
||
|
|
name: 'onclick',
|
||
|
|
evaluate: _scope => (event) => { _scope.handleSelect(event, _scope.position) }
|
||
|
|
}
|
||
|
|
]
|
||
|
|
}
|
||
|
|
]
|
||
|
|
),
|
||
|
|
|
||
|
|
redundantAttribute: 'expr8',
|
||
|
|
selector: '[expr8]',
|
||
|
|
itemName: 'slide',
|
||
|
|
indexName: 'position',
|
||
|
|
evaluate: _scope => _scope.props.slides
|
||
|
|
}
|
||
|
|
]
|
||
|
|
),
|
||
|
|
|
||
|
|
name: 'tiny-slider'
|
||
|
|
});
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./src/example.js":
|
||
|
|
/*!************************!*\
|
||
|
|
!*** ./src/example.js ***!
|
||
|
|
\************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony import */ var riot__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! riot */ "./node_modules/riot/esm/api/register.js");
|
||
|
|
/* harmony import */ var riot__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! riot */ "./node_modules/riot/esm/api/install.js");
|
||
|
|
/* harmony import */ var riot__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! riot */ "./node_modules/riot/esm/riot.js");
|
||
|
|
/* harmony import */ var _slider_riot__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./slider.riot */ "./src/slider.riot");
|
||
|
|
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
|
||
|
|
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
||
|
|
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
|
||
|
|
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
|
||
|
|
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
||
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
||
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
||
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
|
||
|
|
function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
|
||
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
||
|
|
|
||
|
|
|
||
|
|
riot__WEBPACK_IMPORTED_MODULE_1__.register('tiny-slider', _slider_riot__WEBPACK_IMPORTED_MODULE_0__["default"]);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Convert object attributes constructs into strings
|
||
|
|
*
|
||
|
|
* @param {Object} attributes - style attributes as object
|
||
|
|
* @returns {string} a string with all the attributes and their values
|
||
|
|
*/
|
||
|
|
function styles(attributes) {
|
||
|
|
return Object.entries(attributes).reduce(function (acc, item) {
|
||
|
|
var _item = _slicedToArray(item, 2),
|
||
|
|
key = _item[0],
|
||
|
|
value = _item[1];
|
||
|
|
return [].concat(_toConsumableArray(acc), ["".concat(key, ": ").concat(value)]);
|
||
|
|
}, []).join(';');
|
||
|
|
}
|
||
|
|
riot__WEBPACK_IMPORTED_MODULE_2__.install(function (component) {
|
||
|
|
component.styles = styles;
|
||
|
|
return component;
|
||
|
|
});
|
||
|
|
window.riot = riot__WEBPACK_IMPORTED_MODULE_3__;
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./src/mixin.js":
|
||
|
|
/*!**********************!*\
|
||
|
|
!*** ./src/mixin.js ***!
|
||
|
|
\**********************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var hammerjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! hammerjs */ "./node_modules/hammerjs/hammer.js");
|
||
|
|
/* harmony import */ var hammerjs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(hammerjs__WEBPACK_IMPORTED_MODULE_0__);
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
state: {
|
||
|
|
position: 0,
|
||
|
|
max: 0,
|
||
|
|
classes: {
|
||
|
|
item: 'tiny-slider__item'
|
||
|
|
}
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
onMounted: function onMounted() {
|
||
|
|
var _this = this;
|
||
|
|
// start and add resize listener
|
||
|
|
window.addEventListener('resize', this.update.bind(this));
|
||
|
|
setTimeout(function () {
|
||
|
|
_this.update();
|
||
|
|
}, 100);
|
||
|
|
|
||
|
|
// Create a manager to manager the element
|
||
|
|
var manager = new hammerjs__WEBPACK_IMPORTED_MODULE_0__(this.root);
|
||
|
|
manager.on('swipe', function (event) {
|
||
|
|
if (event.direction === 4) {
|
||
|
|
_this.handlePrevious(event);
|
||
|
|
} else if (event.direction === 2) {
|
||
|
|
_this.handleNext(event);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* remove resize listener
|
||
|
|
* before unmount
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
onBeforeUnmount: function onBeforeUnmount() {
|
||
|
|
window.removeEventListener('resize', this.update.bind(this));
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* before update view, calculate values
|
||
|
|
*
|
||
|
|
* @param {object} props
|
||
|
|
* @param {object} state
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
onBeforeUpdate: function onBeforeUpdate(props, state) {
|
||
|
|
var _this2 = this;
|
||
|
|
// getting current max
|
||
|
|
var max = this.state.max;
|
||
|
|
|
||
|
|
// setting max to show visible
|
||
|
|
this.state.max = 0;
|
||
|
|
this.state.width = this.$('.' + this.state.classes.item).offsetWidth;
|
||
|
|
|
||
|
|
// check how many elements can visible in element
|
||
|
|
this.$$('.' + this.state.classes.item).forEach(function (element, index) {
|
||
|
|
if (element.offsetLeft < _this2.root.offsetWidth) {
|
||
|
|
_this2.state.max++;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
console.log(this.state.max);
|
||
|
|
|
||
|
|
// change position to fit new max value
|
||
|
|
var value = Math.abs(this.state.max - max);
|
||
|
|
|
||
|
|
// @TODO check this, at 0 it makes me mad
|
||
|
|
if (this.state.position >= value && this.state.position > 1) {
|
||
|
|
this.state.position -= value;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* set translate with position and witdh
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* @return {string}
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
getContentStyles: function getContentStyles() {
|
||
|
|
// getting value for position
|
||
|
|
var value = -(this.state.position * this.state.width);
|
||
|
|
return this.styles({
|
||
|
|
transform: 'translate(' + value + 'px, 0px)'
|
||
|
|
});
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* set previous position
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
handleSelect: function handleSelect(event, position) {
|
||
|
|
event.preventDefault();
|
||
|
|
if (this.state.position !== position) {
|
||
|
|
this.update({
|
||
|
|
position: position
|
||
|
|
});
|
||
|
|
}
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* set previous position
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
handlePrevious: function handlePrevious(event) {
|
||
|
|
event.preventDefault();
|
||
|
|
if (this.state.position > 0) {
|
||
|
|
this.update({
|
||
|
|
position: --this.state.position
|
||
|
|
});
|
||
|
|
}
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* set next position
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
handleNext: function handleNext(event) {
|
||
|
|
event.preventDefault();
|
||
|
|
if (this.state.position < this.props.slides.length - 1) {
|
||
|
|
this.update({
|
||
|
|
position: ++this.state.position
|
||
|
|
});
|
||
|
|
}
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* @return {string}
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
getPreviousClasses: function getPreviousClasses() {
|
||
|
|
var classes = ['tiny-slider__button', 'tiny-slider__button--previous'];
|
||
|
|
if (this.state.position > 0) {
|
||
|
|
classes.push('visibility-visible');
|
||
|
|
} else {
|
||
|
|
classes.push('visibility-hidden');
|
||
|
|
}
|
||
|
|
return classes.join(' ');
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* @return {string}
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
getNextClasses: function getNextClasses() {
|
||
|
|
var classes = ['tiny-slider__button', 'tiny-slider__button--next'];
|
||
|
|
if (this.state.position <= this.props.slides.length - this.state.max) {
|
||
|
|
classes.push('visibility-visible');
|
||
|
|
} else {
|
||
|
|
classes.push('visibility-hidden');
|
||
|
|
}
|
||
|
|
return classes.join(' ');
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* @param {integer} position
|
||
|
|
* @return {string}
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
getSelectClasses: function getSelectClasses(position) {
|
||
|
|
var classes = ['tiny-slider__select-item'];
|
||
|
|
if (this.state.position === position) {
|
||
|
|
classes.push('tiny-slider__select-item--current');
|
||
|
|
}
|
||
|
|
return classes.join(' ');
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/hammerjs/hammer.js":
|
||
|
|
/*!*****************************************!*\
|
||
|
|
!*** ./node_modules/hammerjs/hammer.js ***!
|
||
|
|
\*****************************************/
|
||
|
|
/***/ ((module, exports, __webpack_require__) => {
|
||
|
|
|
||
|
|
var __WEBPACK_AMD_DEFINE_RESULT__;/*! Hammer.JS - v2.0.7 - 2016-04-22
|
||
|
|
* http://hammerjs.github.io/
|
||
|
|
*
|
||
|
|
* Copyright (c) 2016 Jorik Tangelder;
|
||
|
|
* Licensed under the MIT license */
|
||
|
|
(function(window, document, exportName, undefined) {
|
||
|
|
'use strict';
|
||
|
|
|
||
|
|
var VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];
|
||
|
|
var TEST_ELEMENT = document.createElement('div');
|
||
|
|
|
||
|
|
var TYPE_FUNCTION = 'function';
|
||
|
|
|
||
|
|
var round = Math.round;
|
||
|
|
var abs = Math.abs;
|
||
|
|
var now = Date.now;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* set a timeout with a given scope
|
||
|
|
* @param {Function} fn
|
||
|
|
* @param {Number} timeout
|
||
|
|
* @param {Object} context
|
||
|
|
* @returns {number}
|
||
|
|
*/
|
||
|
|
function setTimeoutContext(fn, timeout, context) {
|
||
|
|
return setTimeout(bindFn(fn, context), timeout);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* if the argument is an array, we want to execute the fn on each entry
|
||
|
|
* if it aint an array we don't want to do a thing.
|
||
|
|
* this is used by all the methods that accept a single and array argument.
|
||
|
|
* @param {*|Array} arg
|
||
|
|
* @param {String} fn
|
||
|
|
* @param {Object} [context]
|
||
|
|
* @returns {Boolean}
|
||
|
|
*/
|
||
|
|
function invokeArrayArg(arg, fn, context) {
|
||
|
|
if (Array.isArray(arg)) {
|
||
|
|
each(arg, context[fn], context);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* walk objects and arrays
|
||
|
|
* @param {Object} obj
|
||
|
|
* @param {Function} iterator
|
||
|
|
* @param {Object} context
|
||
|
|
*/
|
||
|
|
function each(obj, iterator, context) {
|
||
|
|
var i;
|
||
|
|
|
||
|
|
if (!obj) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (obj.forEach) {
|
||
|
|
obj.forEach(iterator, context);
|
||
|
|
} else if (obj.length !== undefined) {
|
||
|
|
i = 0;
|
||
|
|
while (i < obj.length) {
|
||
|
|
iterator.call(context, obj[i], i, obj);
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (i in obj) {
|
||
|
|
obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* wrap a method with a deprecation warning and stack trace
|
||
|
|
* @param {Function} method
|
||
|
|
* @param {String} name
|
||
|
|
* @param {String} message
|
||
|
|
* @returns {Function} A new function wrapping the supplied method.
|
||
|
|
*/
|
||
|
|
function deprecate(method, name, message) {
|
||
|
|
var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\n' + message + ' AT \n';
|
||
|
|
return function() {
|
||
|
|
var e = new Error('get-stack-trace');
|
||
|
|
var stack = e && e.stack ? e.stack.replace(/^[^\(]+?[\n$]/gm, '')
|
||
|
|
.replace(/^\s+at\s+/gm, '')
|
||
|
|
.replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';
|
||
|
|
|
||
|
|
var log = window.console && (window.console.warn || window.console.log);
|
||
|
|
if (log) {
|
||
|
|
log.call(window.console, deprecationMessage, stack);
|
||
|
|
}
|
||
|
|
return method.apply(this, arguments);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* extend object.
|
||
|
|
* means that properties in dest will be overwritten by the ones in src.
|
||
|
|
* @param {Object} target
|
||
|
|
* @param {...Object} objects_to_assign
|
||
|
|
* @returns {Object} target
|
||
|
|
*/
|
||
|
|
var assign;
|
||
|
|
if (typeof Object.assign !== 'function') {
|
||
|
|
assign = function assign(target) {
|
||
|
|
if (target === undefined || target === null) {
|
||
|
|
throw new TypeError('Cannot convert undefined or null to object');
|
||
|
|
}
|
||
|
|
|
||
|
|
var output = Object(target);
|
||
|
|
for (var index = 1; index < arguments.length; index++) {
|
||
|
|
var source = arguments[index];
|
||
|
|
if (source !== undefined && source !== null) {
|
||
|
|
for (var nextKey in source) {
|
||
|
|
if (source.hasOwnProperty(nextKey)) {
|
||
|
|
output[nextKey] = source[nextKey];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return output;
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
assign = Object.assign;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* extend object.
|
||
|
|
* means that properties in dest will be overwritten by the ones in src.
|
||
|
|
* @param {Object} dest
|
||
|
|
* @param {Object} src
|
||
|
|
* @param {Boolean} [merge=false]
|
||
|
|
* @returns {Object} dest
|
||
|
|
*/
|
||
|
|
var extend = deprecate(function extend(dest, src, merge) {
|
||
|
|
var keys = Object.keys(src);
|
||
|
|
var i = 0;
|
||
|
|
while (i < keys.length) {
|
||
|
|
if (!merge || (merge && dest[keys[i]] === undefined)) {
|
||
|
|
dest[keys[i]] = src[keys[i]];
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return dest;
|
||
|
|
}, 'extend', 'Use `assign`.');
|
||
|
|
|
||
|
|
/**
|
||
|
|
* merge the values from src in the dest.
|
||
|
|
* means that properties that exist in dest will not be overwritten by src
|
||
|
|
* @param {Object} dest
|
||
|
|
* @param {Object} src
|
||
|
|
* @returns {Object} dest
|
||
|
|
*/
|
||
|
|
var merge = deprecate(function merge(dest, src) {
|
||
|
|
return extend(dest, src, true);
|
||
|
|
}, 'merge', 'Use `assign`.');
|
||
|
|
|
||
|
|
/**
|
||
|
|
* simple class inheritance
|
||
|
|
* @param {Function} child
|
||
|
|
* @param {Function} base
|
||
|
|
* @param {Object} [properties]
|
||
|
|
*/
|
||
|
|
function inherit(child, base, properties) {
|
||
|
|
var baseP = base.prototype,
|
||
|
|
childP;
|
||
|
|
|
||
|
|
childP = child.prototype = Object.create(baseP);
|
||
|
|
childP.constructor = child;
|
||
|
|
childP._super = baseP;
|
||
|
|
|
||
|
|
if (properties) {
|
||
|
|
assign(childP, properties);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* simple function bind
|
||
|
|
* @param {Function} fn
|
||
|
|
* @param {Object} context
|
||
|
|
* @returns {Function}
|
||
|
|
*/
|
||
|
|
function bindFn(fn, context) {
|
||
|
|
return function boundFn() {
|
||
|
|
return fn.apply(context, arguments);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* let a boolean value also be a function that must return a boolean
|
||
|
|
* this first item in args will be used as the context
|
||
|
|
* @param {Boolean|Function} val
|
||
|
|
* @param {Array} [args]
|
||
|
|
* @returns {Boolean}
|
||
|
|
*/
|
||
|
|
function boolOrFn(val, args) {
|
||
|
|
if (typeof val == TYPE_FUNCTION) {
|
||
|
|
return val.apply(args ? args[0] || undefined : undefined, args);
|
||
|
|
}
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* use the val2 when val1 is undefined
|
||
|
|
* @param {*} val1
|
||
|
|
* @param {*} val2
|
||
|
|
* @returns {*}
|
||
|
|
*/
|
||
|
|
function ifUndefined(val1, val2) {
|
||
|
|
return (val1 === undefined) ? val2 : val1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* addEventListener with multiple events at once
|
||
|
|
* @param {EventTarget} target
|
||
|
|
* @param {String} types
|
||
|
|
* @param {Function} handler
|
||
|
|
*/
|
||
|
|
function addEventListeners(target, types, handler) {
|
||
|
|
each(splitStr(types), function(type) {
|
||
|
|
target.addEventListener(type, handler, false);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* removeEventListener with multiple events at once
|
||
|
|
* @param {EventTarget} target
|
||
|
|
* @param {String} types
|
||
|
|
* @param {Function} handler
|
||
|
|
*/
|
||
|
|
function removeEventListeners(target, types, handler) {
|
||
|
|
each(splitStr(types), function(type) {
|
||
|
|
target.removeEventListener(type, handler, false);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* find if a node is in the given parent
|
||
|
|
* @method hasParent
|
||
|
|
* @param {HTMLElement} node
|
||
|
|
* @param {HTMLElement} parent
|
||
|
|
* @return {Boolean} found
|
||
|
|
*/
|
||
|
|
function hasParent(node, parent) {
|
||
|
|
while (node) {
|
||
|
|
if (node == parent) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
node = node.parentNode;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* small indexOf wrapper
|
||
|
|
* @param {String} str
|
||
|
|
* @param {String} find
|
||
|
|
* @returns {Boolean} found
|
||
|
|
*/
|
||
|
|
function inStr(str, find) {
|
||
|
|
return str.indexOf(find) > -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* split string on whitespace
|
||
|
|
* @param {String} str
|
||
|
|
* @returns {Array} words
|
||
|
|
*/
|
||
|
|
function splitStr(str) {
|
||
|
|
return str.trim().split(/\s+/g);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* find if a array contains the object using indexOf or a simple polyFill
|
||
|
|
* @param {Array} src
|
||
|
|
* @param {String} find
|
||
|
|
* @param {String} [findByKey]
|
||
|
|
* @return {Boolean|Number} false when not found, or the index
|
||
|
|
*/
|
||
|
|
function inArray(src, find, findByKey) {
|
||
|
|
if (src.indexOf && !findByKey) {
|
||
|
|
return src.indexOf(find);
|
||
|
|
} else {
|
||
|
|
var i = 0;
|
||
|
|
while (i < src.length) {
|
||
|
|
if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* convert array-like objects to real arrays
|
||
|
|
* @param {Object} obj
|
||
|
|
* @returns {Array}
|
||
|
|
*/
|
||
|
|
function toArray(obj) {
|
||
|
|
return Array.prototype.slice.call(obj, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* unique array with objects based on a key (like 'id') or just by the array's value
|
||
|
|
* @param {Array} src [{id:1},{id:2},{id:1}]
|
||
|
|
* @param {String} [key]
|
||
|
|
* @param {Boolean} [sort=False]
|
||
|
|
* @returns {Array} [{id:1},{id:2}]
|
||
|
|
*/
|
||
|
|
function uniqueArray(src, key, sort) {
|
||
|
|
var results = [];
|
||
|
|
var values = [];
|
||
|
|
var i = 0;
|
||
|
|
|
||
|
|
while (i < src.length) {
|
||
|
|
var val = key ? src[i][key] : src[i];
|
||
|
|
if (inArray(values, val) < 0) {
|
||
|
|
results.push(src[i]);
|
||
|
|
}
|
||
|
|
values[i] = val;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sort) {
|
||
|
|
if (!key) {
|
||
|
|
results = results.sort();
|
||
|
|
} else {
|
||
|
|
results = results.sort(function sortUniqueArray(a, b) {
|
||
|
|
return a[key] > b[key];
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return results;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get the prefixed property
|
||
|
|
* @param {Object} obj
|
||
|
|
* @param {String} property
|
||
|
|
* @returns {String|Undefined} prefixed
|
||
|
|
*/
|
||
|
|
function prefixed(obj, property) {
|
||
|
|
var prefix, prop;
|
||
|
|
var camelProp = property[0].toUpperCase() + property.slice(1);
|
||
|
|
|
||
|
|
var i = 0;
|
||
|
|
while (i < VENDOR_PREFIXES.length) {
|
||
|
|
prefix = VENDOR_PREFIXES[i];
|
||
|
|
prop = (prefix) ? prefix + camelProp : property;
|
||
|
|
|
||
|
|
if (prop in obj) {
|
||
|
|
return prop;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get a unique id
|
||
|
|
* @returns {number} uniqueId
|
||
|
|
*/
|
||
|
|
var _uniqueId = 1;
|
||
|
|
function uniqueId() {
|
||
|
|
return _uniqueId++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get the window object of an element
|
||
|
|
* @param {HTMLElement} element
|
||
|
|
* @returns {DocumentView|Window}
|
||
|
|
*/
|
||
|
|
function getWindowForElement(element) {
|
||
|
|
var doc = element.ownerDocument || element;
|
||
|
|
return (doc.defaultView || doc.parentWindow || window);
|
||
|
|
}
|
||
|
|
|
||
|
|
var MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;
|
||
|
|
|
||
|
|
var SUPPORT_TOUCH = ('ontouchstart' in window);
|
||
|
|
var SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;
|
||
|
|
var SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);
|
||
|
|
|
||
|
|
var INPUT_TYPE_TOUCH = 'touch';
|
||
|
|
var INPUT_TYPE_PEN = 'pen';
|
||
|
|
var INPUT_TYPE_MOUSE = 'mouse';
|
||
|
|
var INPUT_TYPE_KINECT = 'kinect';
|
||
|
|
|
||
|
|
var COMPUTE_INTERVAL = 25;
|
||
|
|
|
||
|
|
var INPUT_START = 1;
|
||
|
|
var INPUT_MOVE = 2;
|
||
|
|
var INPUT_END = 4;
|
||
|
|
var INPUT_CANCEL = 8;
|
||
|
|
|
||
|
|
var DIRECTION_NONE = 1;
|
||
|
|
var DIRECTION_LEFT = 2;
|
||
|
|
var DIRECTION_RIGHT = 4;
|
||
|
|
var DIRECTION_UP = 8;
|
||
|
|
var DIRECTION_DOWN = 16;
|
||
|
|
|
||
|
|
var DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;
|
||
|
|
var DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;
|
||
|
|
var DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;
|
||
|
|
|
||
|
|
var PROPS_XY = ['x', 'y'];
|
||
|
|
var PROPS_CLIENT_XY = ['clientX', 'clientY'];
|
||
|
|
|
||
|
|
/**
|
||
|
|
* create new input type manager
|
||
|
|
* @param {Manager} manager
|
||
|
|
* @param {Function} callback
|
||
|
|
* @returns {Input}
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
function Input(manager, callback) {
|
||
|
|
var self = this;
|
||
|
|
this.manager = manager;
|
||
|
|
this.callback = callback;
|
||
|
|
this.element = manager.element;
|
||
|
|
this.target = manager.options.inputTarget;
|
||
|
|
|
||
|
|
// smaller wrapper around the handler, for the scope and the enabled state of the manager,
|
||
|
|
// so when disabled the input events are completely bypassed.
|
||
|
|
this.domHandler = function(ev) {
|
||
|
|
if (boolOrFn(manager.options.enable, [manager])) {
|
||
|
|
self.handler(ev);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
this.init();
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
Input.prototype = {
|
||
|
|
/**
|
||
|
|
* should handle the inputEvent data and trigger the callback
|
||
|
|
* @virtual
|
||
|
|
*/
|
||
|
|
handler: function() { },
|
||
|
|
|
||
|
|
/**
|
||
|
|
* bind the events
|
||
|
|
*/
|
||
|
|
init: function() {
|
||
|
|
this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);
|
||
|
|
this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);
|
||
|
|
this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* unbind the events
|
||
|
|
*/
|
||
|
|
destroy: function() {
|
||
|
|
this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);
|
||
|
|
this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);
|
||
|
|
this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* create new input type manager
|
||
|
|
* called by the Manager constructor
|
||
|
|
* @param {Hammer} manager
|
||
|
|
* @returns {Input}
|
||
|
|
*/
|
||
|
|
function createInputInstance(manager) {
|
||
|
|
var Type;
|
||
|
|
var inputClass = manager.options.inputClass;
|
||
|
|
|
||
|
|
if (inputClass) {
|
||
|
|
Type = inputClass;
|
||
|
|
} else if (SUPPORT_POINTER_EVENTS) {
|
||
|
|
Type = PointerEventInput;
|
||
|
|
} else if (SUPPORT_ONLY_TOUCH) {
|
||
|
|
Type = TouchInput;
|
||
|
|
} else if (!SUPPORT_TOUCH) {
|
||
|
|
Type = MouseInput;
|
||
|
|
} else {
|
||
|
|
Type = TouchMouseInput;
|
||
|
|
}
|
||
|
|
return new (Type)(manager, inputHandler);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* handle input events
|
||
|
|
* @param {Manager} manager
|
||
|
|
* @param {String} eventType
|
||
|
|
* @param {Object} input
|
||
|
|
*/
|
||
|
|
function inputHandler(manager, eventType, input) {
|
||
|
|
var pointersLen = input.pointers.length;
|
||
|
|
var changedPointersLen = input.changedPointers.length;
|
||
|
|
var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));
|
||
|
|
var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));
|
||
|
|
|
||
|
|
input.isFirst = !!isFirst;
|
||
|
|
input.isFinal = !!isFinal;
|
||
|
|
|
||
|
|
if (isFirst) {
|
||
|
|
manager.session = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
// source event is the normalized value of the domEvents
|
||
|
|
// like 'touchstart, mouseup, pointerdown'
|
||
|
|
input.eventType = eventType;
|
||
|
|
|
||
|
|
// compute scale, rotation etc
|
||
|
|
computeInputData(manager, input);
|
||
|
|
|
||
|
|
// emit secret event
|
||
|
|
manager.emit('hammer.input', input);
|
||
|
|
|
||
|
|
manager.recognize(input);
|
||
|
|
manager.session.prevInput = input;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* extend the data with some usable properties like scale, rotate, velocity etc
|
||
|
|
* @param {Object} manager
|
||
|
|
* @param {Object} input
|
||
|
|
*/
|
||
|
|
function computeInputData(manager, input) {
|
||
|
|
var session = manager.session;
|
||
|
|
var pointers = input.pointers;
|
||
|
|
var pointersLength = pointers.length;
|
||
|
|
|
||
|
|
// store the first input to calculate the distance and direction
|
||
|
|
if (!session.firstInput) {
|
||
|
|
session.firstInput = simpleCloneInputData(input);
|
||
|
|
}
|
||
|
|
|
||
|
|
// to compute scale and rotation we need to store the multiple touches
|
||
|
|
if (pointersLength > 1 && !session.firstMultiple) {
|
||
|
|
session.firstMultiple = simpleCloneInputData(input);
|
||
|
|
} else if (pointersLength === 1) {
|
||
|
|
session.firstMultiple = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
var firstInput = session.firstInput;
|
||
|
|
var firstMultiple = session.firstMultiple;
|
||
|
|
var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;
|
||
|
|
|
||
|
|
var center = input.center = getCenter(pointers);
|
||
|
|
input.timeStamp = now();
|
||
|
|
input.deltaTime = input.timeStamp - firstInput.timeStamp;
|
||
|
|
|
||
|
|
input.angle = getAngle(offsetCenter, center);
|
||
|
|
input.distance = getDistance(offsetCenter, center);
|
||
|
|
|
||
|
|
computeDeltaXY(session, input);
|
||
|
|
input.offsetDirection = getDirection(input.deltaX, input.deltaY);
|
||
|
|
|
||
|
|
var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);
|
||
|
|
input.overallVelocityX = overallVelocity.x;
|
||
|
|
input.overallVelocityY = overallVelocity.y;
|
||
|
|
input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;
|
||
|
|
|
||
|
|
input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;
|
||
|
|
input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;
|
||
|
|
|
||
|
|
input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >
|
||
|
|
session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);
|
||
|
|
|
||
|
|
computeIntervalInputData(session, input);
|
||
|
|
|
||
|
|
// find the correct target
|
||
|
|
var target = manager.element;
|
||
|
|
if (hasParent(input.srcEvent.target, target)) {
|
||
|
|
target = input.srcEvent.target;
|
||
|
|
}
|
||
|
|
input.target = target;
|
||
|
|
}
|
||
|
|
|
||
|
|
function computeDeltaXY(session, input) {
|
||
|
|
var center = input.center;
|
||
|
|
var offset = session.offsetDelta || {};
|
||
|
|
var prevDelta = session.prevDelta || {};
|
||
|
|
var prevInput = session.prevInput || {};
|
||
|
|
|
||
|
|
if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {
|
||
|
|
prevDelta = session.prevDelta = {
|
||
|
|
x: prevInput.deltaX || 0,
|
||
|
|
y: prevInput.deltaY || 0
|
||
|
|
};
|
||
|
|
|
||
|
|
offset = session.offsetDelta = {
|
||
|
|
x: center.x,
|
||
|
|
y: center.y
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
input.deltaX = prevDelta.x + (center.x - offset.x);
|
||
|
|
input.deltaY = prevDelta.y + (center.y - offset.y);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* velocity is calculated every x ms
|
||
|
|
* @param {Object} session
|
||
|
|
* @param {Object} input
|
||
|
|
*/
|
||
|
|
function computeIntervalInputData(session, input) {
|
||
|
|
var last = session.lastInterval || input,
|
||
|
|
deltaTime = input.timeStamp - last.timeStamp,
|
||
|
|
velocity, velocityX, velocityY, direction;
|
||
|
|
|
||
|
|
if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {
|
||
|
|
var deltaX = input.deltaX - last.deltaX;
|
||
|
|
var deltaY = input.deltaY - last.deltaY;
|
||
|
|
|
||
|
|
var v = getVelocity(deltaTime, deltaX, deltaY);
|
||
|
|
velocityX = v.x;
|
||
|
|
velocityY = v.y;
|
||
|
|
velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;
|
||
|
|
direction = getDirection(deltaX, deltaY);
|
||
|
|
|
||
|
|
session.lastInterval = input;
|
||
|
|
} else {
|
||
|
|
// use latest velocity info if it doesn't overtake a minimum period
|
||
|
|
velocity = last.velocity;
|
||
|
|
velocityX = last.velocityX;
|
||
|
|
velocityY = last.velocityY;
|
||
|
|
direction = last.direction;
|
||
|
|
}
|
||
|
|
|
||
|
|
input.velocity = velocity;
|
||
|
|
input.velocityX = velocityX;
|
||
|
|
input.velocityY = velocityY;
|
||
|
|
input.direction = direction;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* create a simple clone from the input used for storage of firstInput and firstMultiple
|
||
|
|
* @param {Object} input
|
||
|
|
* @returns {Object} clonedInputData
|
||
|
|
*/
|
||
|
|
function simpleCloneInputData(input) {
|
||
|
|
// make a simple copy of the pointers because we will get a reference if we don't
|
||
|
|
// we only need clientXY for the calculations
|
||
|
|
var pointers = [];
|
||
|
|
var i = 0;
|
||
|
|
while (i < input.pointers.length) {
|
||
|
|
pointers[i] = {
|
||
|
|
clientX: round(input.pointers[i].clientX),
|
||
|
|
clientY: round(input.pointers[i].clientY)
|
||
|
|
};
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
timeStamp: now(),
|
||
|
|
pointers: pointers,
|
||
|
|
center: getCenter(pointers),
|
||
|
|
deltaX: input.deltaX,
|
||
|
|
deltaY: input.deltaY
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get the center of all the pointers
|
||
|
|
* @param {Array} pointers
|
||
|
|
* @return {Object} center contains `x` and `y` properties
|
||
|
|
*/
|
||
|
|
function getCenter(pointers) {
|
||
|
|
var pointersLength = pointers.length;
|
||
|
|
|
||
|
|
// no need to loop when only one touch
|
||
|
|
if (pointersLength === 1) {
|
||
|
|
return {
|
||
|
|
x: round(pointers[0].clientX),
|
||
|
|
y: round(pointers[0].clientY)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
var x = 0, y = 0, i = 0;
|
||
|
|
while (i < pointersLength) {
|
||
|
|
x += pointers[i].clientX;
|
||
|
|
y += pointers[i].clientY;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
x: round(x / pointersLength),
|
||
|
|
y: round(y / pointersLength)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* calculate the velocity between two points. unit is in px per ms.
|
||
|
|
* @param {Number} deltaTime
|
||
|
|
* @param {Number} x
|
||
|
|
* @param {Number} y
|
||
|
|
* @return {Object} velocity `x` and `y`
|
||
|
|
*/
|
||
|
|
function getVelocity(deltaTime, x, y) {
|
||
|
|
return {
|
||
|
|
x: x / deltaTime || 0,
|
||
|
|
y: y / deltaTime || 0
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get the direction between two points
|
||
|
|
* @param {Number} x
|
||
|
|
* @param {Number} y
|
||
|
|
* @return {Number} direction
|
||
|
|
*/
|
||
|
|
function getDirection(x, y) {
|
||
|
|
if (x === y) {
|
||
|
|
return DIRECTION_NONE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (abs(x) >= abs(y)) {
|
||
|
|
return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
|
||
|
|
}
|
||
|
|
return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* calculate the absolute distance between two points
|
||
|
|
* @param {Object} p1 {x, y}
|
||
|
|
* @param {Object} p2 {x, y}
|
||
|
|
* @param {Array} [props] containing x and y keys
|
||
|
|
* @return {Number} distance
|
||
|
|
*/
|
||
|
|
function getDistance(p1, p2, props) {
|
||
|
|
if (!props) {
|
||
|
|
props = PROPS_XY;
|
||
|
|
}
|
||
|
|
var x = p2[props[0]] - p1[props[0]],
|
||
|
|
y = p2[props[1]] - p1[props[1]];
|
||
|
|
|
||
|
|
return Math.sqrt((x * x) + (y * y));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* calculate the angle between two coordinates
|
||
|
|
* @param {Object} p1
|
||
|
|
* @param {Object} p2
|
||
|
|
* @param {Array} [props] containing x and y keys
|
||
|
|
* @return {Number} angle
|
||
|
|
*/
|
||
|
|
function getAngle(p1, p2, props) {
|
||
|
|
if (!props) {
|
||
|
|
props = PROPS_XY;
|
||
|
|
}
|
||
|
|
var x = p2[props[0]] - p1[props[0]],
|
||
|
|
y = p2[props[1]] - p1[props[1]];
|
||
|
|
return Math.atan2(y, x) * 180 / Math.PI;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* calculate the rotation degrees between two pointersets
|
||
|
|
* @param {Array} start array of pointers
|
||
|
|
* @param {Array} end array of pointers
|
||
|
|
* @return {Number} rotation
|
||
|
|
*/
|
||
|
|
function getRotation(start, end) {
|
||
|
|
return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* calculate the scale factor between two pointersets
|
||
|
|
* no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
|
||
|
|
* @param {Array} start array of pointers
|
||
|
|
* @param {Array} end array of pointers
|
||
|
|
* @return {Number} scale
|
||
|
|
*/
|
||
|
|
function getScale(start, end) {
|
||
|
|
return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);
|
||
|
|
}
|
||
|
|
|
||
|
|
var MOUSE_INPUT_MAP = {
|
||
|
|
mousedown: INPUT_START,
|
||
|
|
mousemove: INPUT_MOVE,
|
||
|
|
mouseup: INPUT_END
|
||
|
|
};
|
||
|
|
|
||
|
|
var MOUSE_ELEMENT_EVENTS = 'mousedown';
|
||
|
|
var MOUSE_WINDOW_EVENTS = 'mousemove mouseup';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Mouse events input
|
||
|
|
* @constructor
|
||
|
|
* @extends Input
|
||
|
|
*/
|
||
|
|
function MouseInput() {
|
||
|
|
this.evEl = MOUSE_ELEMENT_EVENTS;
|
||
|
|
this.evWin = MOUSE_WINDOW_EVENTS;
|
||
|
|
|
||
|
|
this.pressed = false; // mousedown state
|
||
|
|
|
||
|
|
Input.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(MouseInput, Input, {
|
||
|
|
/**
|
||
|
|
* handle mouse events
|
||
|
|
* @param {Object} ev
|
||
|
|
*/
|
||
|
|
handler: function MEhandler(ev) {
|
||
|
|
var eventType = MOUSE_INPUT_MAP[ev.type];
|
||
|
|
|
||
|
|
// on start we want to have the left mouse button down
|
||
|
|
if (eventType & INPUT_START && ev.button === 0) {
|
||
|
|
this.pressed = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType & INPUT_MOVE && ev.which !== 1) {
|
||
|
|
eventType = INPUT_END;
|
||
|
|
}
|
||
|
|
|
||
|
|
// mouse must be down
|
||
|
|
if (!this.pressed) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventType & INPUT_END) {
|
||
|
|
this.pressed = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.callback(this.manager, eventType, {
|
||
|
|
pointers: [ev],
|
||
|
|
changedPointers: [ev],
|
||
|
|
pointerType: INPUT_TYPE_MOUSE,
|
||
|
|
srcEvent: ev
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
var POINTER_INPUT_MAP = {
|
||
|
|
pointerdown: INPUT_START,
|
||
|
|
pointermove: INPUT_MOVE,
|
||
|
|
pointerup: INPUT_END,
|
||
|
|
pointercancel: INPUT_CANCEL,
|
||
|
|
pointerout: INPUT_CANCEL
|
||
|
|
};
|
||
|
|
|
||
|
|
// in IE10 the pointer types is defined as an enum
|
||
|
|
var IE10_POINTER_TYPE_ENUM = {
|
||
|
|
2: INPUT_TYPE_TOUCH,
|
||
|
|
3: INPUT_TYPE_PEN,
|
||
|
|
4: INPUT_TYPE_MOUSE,
|
||
|
|
5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816
|
||
|
|
};
|
||
|
|
|
||
|
|
var POINTER_ELEMENT_EVENTS = 'pointerdown';
|
||
|
|
var POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';
|
||
|
|
|
||
|
|
// IE10 has prefixed support, and case-sensitive
|
||
|
|
if (window.MSPointerEvent && !window.PointerEvent) {
|
||
|
|
POINTER_ELEMENT_EVENTS = 'MSPointerDown';
|
||
|
|
POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Pointer events input
|
||
|
|
* @constructor
|
||
|
|
* @extends Input
|
||
|
|
*/
|
||
|
|
function PointerEventInput() {
|
||
|
|
this.evEl = POINTER_ELEMENT_EVENTS;
|
||
|
|
this.evWin = POINTER_WINDOW_EVENTS;
|
||
|
|
|
||
|
|
Input.apply(this, arguments);
|
||
|
|
|
||
|
|
this.store = (this.manager.session.pointerEvents = []);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(PointerEventInput, Input, {
|
||
|
|
/**
|
||
|
|
* handle mouse events
|
||
|
|
* @param {Object} ev
|
||
|
|
*/
|
||
|
|
handler: function PEhandler(ev) {
|
||
|
|
var store = this.store;
|
||
|
|
var removePointer = false;
|
||
|
|
|
||
|
|
var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');
|
||
|
|
var eventType = POINTER_INPUT_MAP[eventTypeNormalized];
|
||
|
|
var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;
|
||
|
|
|
||
|
|
var isTouch = (pointerType == INPUT_TYPE_TOUCH);
|
||
|
|
|
||
|
|
// get index of the event in the store
|
||
|
|
var storeIndex = inArray(store, ev.pointerId, 'pointerId');
|
||
|
|
|
||
|
|
// start and mouse must be down
|
||
|
|
if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {
|
||
|
|
if (storeIndex < 0) {
|
||
|
|
store.push(ev);
|
||
|
|
storeIndex = store.length - 1;
|
||
|
|
}
|
||
|
|
} else if (eventType & (INPUT_END | INPUT_CANCEL)) {
|
||
|
|
removePointer = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// it not found, so the pointer hasn't been down (so it's probably a hover)
|
||
|
|
if (storeIndex < 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// update the event in the store
|
||
|
|
store[storeIndex] = ev;
|
||
|
|
|
||
|
|
this.callback(this.manager, eventType, {
|
||
|
|
pointers: store,
|
||
|
|
changedPointers: [ev],
|
||
|
|
pointerType: pointerType,
|
||
|
|
srcEvent: ev
|
||
|
|
});
|
||
|
|
|
||
|
|
if (removePointer) {
|
||
|
|
// remove from the store
|
||
|
|
store.splice(storeIndex, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
var SINGLE_TOUCH_INPUT_MAP = {
|
||
|
|
touchstart: INPUT_START,
|
||
|
|
touchmove: INPUT_MOVE,
|
||
|
|
touchend: INPUT_END,
|
||
|
|
touchcancel: INPUT_CANCEL
|
||
|
|
};
|
||
|
|
|
||
|
|
var SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';
|
||
|
|
var SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Touch events input
|
||
|
|
* @constructor
|
||
|
|
* @extends Input
|
||
|
|
*/
|
||
|
|
function SingleTouchInput() {
|
||
|
|
this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;
|
||
|
|
this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;
|
||
|
|
this.started = false;
|
||
|
|
|
||
|
|
Input.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(SingleTouchInput, Input, {
|
||
|
|
handler: function TEhandler(ev) {
|
||
|
|
var type = SINGLE_TOUCH_INPUT_MAP[ev.type];
|
||
|
|
|
||
|
|
// should we handle the touch events?
|
||
|
|
if (type === INPUT_START) {
|
||
|
|
this.started = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!this.started) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var touches = normalizeSingleTouches.call(this, ev, type);
|
||
|
|
|
||
|
|
// when done, reset the started state
|
||
|
|
if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {
|
||
|
|
this.started = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.callback(this.manager, type, {
|
||
|
|
pointers: touches[0],
|
||
|
|
changedPointers: touches[1],
|
||
|
|
pointerType: INPUT_TYPE_TOUCH,
|
||
|
|
srcEvent: ev
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @this {TouchInput}
|
||
|
|
* @param {Object} ev
|
||
|
|
* @param {Number} type flag
|
||
|
|
* @returns {undefined|Array} [all, changed]
|
||
|
|
*/
|
||
|
|
function normalizeSingleTouches(ev, type) {
|
||
|
|
var all = toArray(ev.touches);
|
||
|
|
var changed = toArray(ev.changedTouches);
|
||
|
|
|
||
|
|
if (type & (INPUT_END | INPUT_CANCEL)) {
|
||
|
|
all = uniqueArray(all.concat(changed), 'identifier', true);
|
||
|
|
}
|
||
|
|
|
||
|
|
return [all, changed];
|
||
|
|
}
|
||
|
|
|
||
|
|
var TOUCH_INPUT_MAP = {
|
||
|
|
touchstart: INPUT_START,
|
||
|
|
touchmove: INPUT_MOVE,
|
||
|
|
touchend: INPUT_END,
|
||
|
|
touchcancel: INPUT_CANCEL
|
||
|
|
};
|
||
|
|
|
||
|
|
var TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Multi-user touch events input
|
||
|
|
* @constructor
|
||
|
|
* @extends Input
|
||
|
|
*/
|
||
|
|
function TouchInput() {
|
||
|
|
this.evTarget = TOUCH_TARGET_EVENTS;
|
||
|
|
this.targetIds = {};
|
||
|
|
|
||
|
|
Input.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(TouchInput, Input, {
|
||
|
|
handler: function MTEhandler(ev) {
|
||
|
|
var type = TOUCH_INPUT_MAP[ev.type];
|
||
|
|
var touches = getTouches.call(this, ev, type);
|
||
|
|
if (!touches) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.callback(this.manager, type, {
|
||
|
|
pointers: touches[0],
|
||
|
|
changedPointers: touches[1],
|
||
|
|
pointerType: INPUT_TYPE_TOUCH,
|
||
|
|
srcEvent: ev
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @this {TouchInput}
|
||
|
|
* @param {Object} ev
|
||
|
|
* @param {Number} type flag
|
||
|
|
* @returns {undefined|Array} [all, changed]
|
||
|
|
*/
|
||
|
|
function getTouches(ev, type) {
|
||
|
|
var allTouches = toArray(ev.touches);
|
||
|
|
var targetIds = this.targetIds;
|
||
|
|
|
||
|
|
// when there is only one touch, the process can be simplified
|
||
|
|
if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {
|
||
|
|
targetIds[allTouches[0].identifier] = true;
|
||
|
|
return [allTouches, allTouches];
|
||
|
|
}
|
||
|
|
|
||
|
|
var i,
|
||
|
|
targetTouches,
|
||
|
|
changedTouches = toArray(ev.changedTouches),
|
||
|
|
changedTargetTouches = [],
|
||
|
|
target = this.target;
|
||
|
|
|
||
|
|
// get target touches from touches
|
||
|
|
targetTouches = allTouches.filter(function(touch) {
|
||
|
|
return hasParent(touch.target, target);
|
||
|
|
});
|
||
|
|
|
||
|
|
// collect touches
|
||
|
|
if (type === INPUT_START) {
|
||
|
|
i = 0;
|
||
|
|
while (i < targetTouches.length) {
|
||
|
|
targetIds[targetTouches[i].identifier] = true;
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// filter changed touches to only contain touches that exist in the collected target ids
|
||
|
|
i = 0;
|
||
|
|
while (i < changedTouches.length) {
|
||
|
|
if (targetIds[changedTouches[i].identifier]) {
|
||
|
|
changedTargetTouches.push(changedTouches[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// cleanup removed touches
|
||
|
|
if (type & (INPUT_END | INPUT_CANCEL)) {
|
||
|
|
delete targetIds[changedTouches[i].identifier];
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!changedTargetTouches.length) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
return [
|
||
|
|
// merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'
|
||
|
|
uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),
|
||
|
|
changedTargetTouches
|
||
|
|
];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Combined touch and mouse input
|
||
|
|
*
|
||
|
|
* Touch has a higher priority then mouse, and while touching no mouse events are allowed.
|
||
|
|
* This because touch devices also emit mouse events while doing a touch.
|
||
|
|
*
|
||
|
|
* @constructor
|
||
|
|
* @extends Input
|
||
|
|
*/
|
||
|
|
|
||
|
|
var DEDUP_TIMEOUT = 2500;
|
||
|
|
var DEDUP_DISTANCE = 25;
|
||
|
|
|
||
|
|
function TouchMouseInput() {
|
||
|
|
Input.apply(this, arguments);
|
||
|
|
|
||
|
|
var handler = bindFn(this.handler, this);
|
||
|
|
this.touch = new TouchInput(this.manager, handler);
|
||
|
|
this.mouse = new MouseInput(this.manager, handler);
|
||
|
|
|
||
|
|
this.primaryTouch = null;
|
||
|
|
this.lastTouches = [];
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(TouchMouseInput, Input, {
|
||
|
|
/**
|
||
|
|
* handle mouse and touch events
|
||
|
|
* @param {Hammer} manager
|
||
|
|
* @param {String} inputEvent
|
||
|
|
* @param {Object} inputData
|
||
|
|
*/
|
||
|
|
handler: function TMEhandler(manager, inputEvent, inputData) {
|
||
|
|
var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),
|
||
|
|
isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);
|
||
|
|
|
||
|
|
if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// when we're in a touch event, record touches to de-dupe synthetic mouse event
|
||
|
|
if (isTouch) {
|
||
|
|
recordTouches.call(this, inputEvent, inputData);
|
||
|
|
} else if (isMouse && isSyntheticEvent.call(this, inputData)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.callback(manager, inputEvent, inputData);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* remove the event listeners
|
||
|
|
*/
|
||
|
|
destroy: function destroy() {
|
||
|
|
this.touch.destroy();
|
||
|
|
this.mouse.destroy();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
function recordTouches(eventType, eventData) {
|
||
|
|
if (eventType & INPUT_START) {
|
||
|
|
this.primaryTouch = eventData.changedPointers[0].identifier;
|
||
|
|
setLastTouch.call(this, eventData);
|
||
|
|
} else if (eventType & (INPUT_END | INPUT_CANCEL)) {
|
||
|
|
setLastTouch.call(this, eventData);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function setLastTouch(eventData) {
|
||
|
|
var touch = eventData.changedPointers[0];
|
||
|
|
|
||
|
|
if (touch.identifier === this.primaryTouch) {
|
||
|
|
var lastTouch = {x: touch.clientX, y: touch.clientY};
|
||
|
|
this.lastTouches.push(lastTouch);
|
||
|
|
var lts = this.lastTouches;
|
||
|
|
var removeLastTouch = function() {
|
||
|
|
var i = lts.indexOf(lastTouch);
|
||
|
|
if (i > -1) {
|
||
|
|
lts.splice(i, 1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
setTimeout(removeLastTouch, DEDUP_TIMEOUT);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function isSyntheticEvent(eventData) {
|
||
|
|
var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;
|
||
|
|
for (var i = 0; i < this.lastTouches.length; i++) {
|
||
|
|
var t = this.lastTouches[i];
|
||
|
|
var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);
|
||
|
|
if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
var PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');
|
||
|
|
var NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;
|
||
|
|
|
||
|
|
// magical touchAction value
|
||
|
|
var TOUCH_ACTION_COMPUTE = 'compute';
|
||
|
|
var TOUCH_ACTION_AUTO = 'auto';
|
||
|
|
var TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented
|
||
|
|
var TOUCH_ACTION_NONE = 'none';
|
||
|
|
var TOUCH_ACTION_PAN_X = 'pan-x';
|
||
|
|
var TOUCH_ACTION_PAN_Y = 'pan-y';
|
||
|
|
var TOUCH_ACTION_MAP = getTouchActionProps();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Touch Action
|
||
|
|
* sets the touchAction property or uses the js alternative
|
||
|
|
* @param {Manager} manager
|
||
|
|
* @param {String} value
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
function TouchAction(manager, value) {
|
||
|
|
this.manager = manager;
|
||
|
|
this.set(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
TouchAction.prototype = {
|
||
|
|
/**
|
||
|
|
* set the touchAction value on the element or enable the polyfill
|
||
|
|
* @param {String} value
|
||
|
|
*/
|
||
|
|
set: function(value) {
|
||
|
|
// find out the touch-action by the event handlers
|
||
|
|
if (value == TOUCH_ACTION_COMPUTE) {
|
||
|
|
value = this.compute();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {
|
||
|
|
this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;
|
||
|
|
}
|
||
|
|
this.actions = value.toLowerCase().trim();
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* just re-set the touchAction value
|
||
|
|
*/
|
||
|
|
update: function() {
|
||
|
|
this.set(this.manager.options.touchAction);
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* compute the value for the touchAction property based on the recognizer's settings
|
||
|
|
* @returns {String} value
|
||
|
|
*/
|
||
|
|
compute: function() {
|
||
|
|
var actions = [];
|
||
|
|
each(this.manager.recognizers, function(recognizer) {
|
||
|
|
if (boolOrFn(recognizer.options.enable, [recognizer])) {
|
||
|
|
actions = actions.concat(recognizer.getTouchAction());
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return cleanTouchActions(actions.join(' '));
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* this method is called on each input cycle and provides the preventing of the browser behavior
|
||
|
|
* @param {Object} input
|
||
|
|
*/
|
||
|
|
preventDefaults: function(input) {
|
||
|
|
var srcEvent = input.srcEvent;
|
||
|
|
var direction = input.offsetDirection;
|
||
|
|
|
||
|
|
// if the touch action did prevented once this session
|
||
|
|
if (this.manager.session.prevented) {
|
||
|
|
srcEvent.preventDefault();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var actions = this.actions;
|
||
|
|
var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];
|
||
|
|
var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];
|
||
|
|
var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];
|
||
|
|
|
||
|
|
if (hasNone) {
|
||
|
|
//do not prevent defaults if this is a tap gesture
|
||
|
|
|
||
|
|
var isTapPointer = input.pointers.length === 1;
|
||
|
|
var isTapMovement = input.distance < 2;
|
||
|
|
var isTapTouchTime = input.deltaTime < 250;
|
||
|
|
|
||
|
|
if (isTapPointer && isTapMovement && isTapTouchTime) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hasPanX && hasPanY) {
|
||
|
|
// `pan-x pan-y` means browser handles all scrolling/panning, do not prevent
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hasNone ||
|
||
|
|
(hasPanY && direction & DIRECTION_HORIZONTAL) ||
|
||
|
|
(hasPanX && direction & DIRECTION_VERTICAL)) {
|
||
|
|
return this.preventSrc(srcEvent);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* call preventDefault to prevent the browser's default behavior (scrolling in most cases)
|
||
|
|
* @param {Object} srcEvent
|
||
|
|
*/
|
||
|
|
preventSrc: function(srcEvent) {
|
||
|
|
this.manager.session.prevented = true;
|
||
|
|
srcEvent.preventDefault();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* when the touchActions are collected they are not a valid value, so we need to clean things up. *
|
||
|
|
* @param {String} actions
|
||
|
|
* @returns {*}
|
||
|
|
*/
|
||
|
|
function cleanTouchActions(actions) {
|
||
|
|
// none
|
||
|
|
if (inStr(actions, TOUCH_ACTION_NONE)) {
|
||
|
|
return TOUCH_ACTION_NONE;
|
||
|
|
}
|
||
|
|
|
||
|
|
var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);
|
||
|
|
var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);
|
||
|
|
|
||
|
|
// if both pan-x and pan-y are set (different recognizers
|
||
|
|
// for different directions, e.g. horizontal pan but vertical swipe?)
|
||
|
|
// we need none (as otherwise with pan-x pan-y combined none of these
|
||
|
|
// recognizers will work, since the browser would handle all panning
|
||
|
|
if (hasPanX && hasPanY) {
|
||
|
|
return TOUCH_ACTION_NONE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// pan-x OR pan-y
|
||
|
|
if (hasPanX || hasPanY) {
|
||
|
|
return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;
|
||
|
|
}
|
||
|
|
|
||
|
|
// manipulation
|
||
|
|
if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {
|
||
|
|
return TOUCH_ACTION_MANIPULATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
return TOUCH_ACTION_AUTO;
|
||
|
|
}
|
||
|
|
|
||
|
|
function getTouchActionProps() {
|
||
|
|
if (!NATIVE_TOUCH_ACTION) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
var touchMap = {};
|
||
|
|
var cssSupports = window.CSS && window.CSS.supports;
|
||
|
|
['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {
|
||
|
|
|
||
|
|
// If css.supports is not supported but there is native touch-action assume it supports
|
||
|
|
// all values. This is the case for IE 10 and 11.
|
||
|
|
touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;
|
||
|
|
});
|
||
|
|
return touchMap;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Recognizer flow explained; *
|
||
|
|
* All recognizers have the initial state of POSSIBLE when a input session starts.
|
||
|
|
* The definition of a input session is from the first input until the last input, with all it's movement in it. *
|
||
|
|
* Example session for mouse-input: mousedown -> mousemove -> mouseup
|
||
|
|
*
|
||
|
|
* On each recognizing cycle (see Manager.recognize) the .recognize() method is executed
|
||
|
|
* which determines with state it should be.
|
||
|
|
*
|
||
|
|
* If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to
|
||
|
|
* POSSIBLE to give it another change on the next cycle.
|
||
|
|
*
|
||
|
|
* Possible
|
||
|
|
* |
|
||
|
|
* +-----+---------------+
|
||
|
|
* | |
|
||
|
|
* +-----+-----+ |
|
||
|
|
* | | |
|
||
|
|
* Failed Cancelled |
|
||
|
|
* +-------+------+
|
||
|
|
* | |
|
||
|
|
* Recognized Began
|
||
|
|
* |
|
||
|
|
* Changed
|
||
|
|
* |
|
||
|
|
* Ended/Recognized
|
||
|
|
*/
|
||
|
|
var STATE_POSSIBLE = 1;
|
||
|
|
var STATE_BEGAN = 2;
|
||
|
|
var STATE_CHANGED = 4;
|
||
|
|
var STATE_ENDED = 8;
|
||
|
|
var STATE_RECOGNIZED = STATE_ENDED;
|
||
|
|
var STATE_CANCELLED = 16;
|
||
|
|
var STATE_FAILED = 32;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Recognizer
|
||
|
|
* Every recognizer needs to extend from this class.
|
||
|
|
* @constructor
|
||
|
|
* @param {Object} options
|
||
|
|
*/
|
||
|
|
function Recognizer(options) {
|
||
|
|
this.options = assign({}, this.defaults, options || {});
|
||
|
|
|
||
|
|
this.id = uniqueId();
|
||
|
|
|
||
|
|
this.manager = null;
|
||
|
|
|
||
|
|
// default is enable true
|
||
|
|
this.options.enable = ifUndefined(this.options.enable, true);
|
||
|
|
|
||
|
|
this.state = STATE_POSSIBLE;
|
||
|
|
|
||
|
|
this.simultaneous = {};
|
||
|
|
this.requireFail = [];
|
||
|
|
}
|
||
|
|
|
||
|
|
Recognizer.prototype = {
|
||
|
|
/**
|
||
|
|
* @virtual
|
||
|
|
* @type {Object}
|
||
|
|
*/
|
||
|
|
defaults: {},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* set options
|
||
|
|
* @param {Object} options
|
||
|
|
* @return {Recognizer}
|
||
|
|
*/
|
||
|
|
set: function(options) {
|
||
|
|
assign(this.options, options);
|
||
|
|
|
||
|
|
// also update the touchAction, in case something changed about the directions/enabled state
|
||
|
|
this.manager && this.manager.touchAction.update();
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* recognize simultaneous with an other recognizer.
|
||
|
|
* @param {Recognizer} otherRecognizer
|
||
|
|
* @returns {Recognizer} this
|
||
|
|
*/
|
||
|
|
recognizeWith: function(otherRecognizer) {
|
||
|
|
if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
var simultaneous = this.simultaneous;
|
||
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
||
|
|
if (!simultaneous[otherRecognizer.id]) {
|
||
|
|
simultaneous[otherRecognizer.id] = otherRecognizer;
|
||
|
|
otherRecognizer.recognizeWith(this);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* drop the simultaneous link. it doesnt remove the link on the other recognizer.
|
||
|
|
* @param {Recognizer} otherRecognizer
|
||
|
|
* @returns {Recognizer} this
|
||
|
|
*/
|
||
|
|
dropRecognizeWith: function(otherRecognizer) {
|
||
|
|
if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
||
|
|
delete this.simultaneous[otherRecognizer.id];
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* recognizer can only run when an other is failing
|
||
|
|
* @param {Recognizer} otherRecognizer
|
||
|
|
* @returns {Recognizer} this
|
||
|
|
*/
|
||
|
|
requireFailure: function(otherRecognizer) {
|
||
|
|
if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
var requireFail = this.requireFail;
|
||
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
||
|
|
if (inArray(requireFail, otherRecognizer) === -1) {
|
||
|
|
requireFail.push(otherRecognizer);
|
||
|
|
otherRecognizer.requireFailure(this);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* drop the requireFailure link. it does not remove the link on the other recognizer.
|
||
|
|
* @param {Recognizer} otherRecognizer
|
||
|
|
* @returns {Recognizer} this
|
||
|
|
*/
|
||
|
|
dropRequireFailure: function(otherRecognizer) {
|
||
|
|
if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);
|
||
|
|
var index = inArray(this.requireFail, otherRecognizer);
|
||
|
|
if (index > -1) {
|
||
|
|
this.requireFail.splice(index, 1);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* has require failures boolean
|
||
|
|
* @returns {boolean}
|
||
|
|
*/
|
||
|
|
hasRequireFailures: function() {
|
||
|
|
return this.requireFail.length > 0;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* if the recognizer can recognize simultaneous with an other recognizer
|
||
|
|
* @param {Recognizer} otherRecognizer
|
||
|
|
* @returns {Boolean}
|
||
|
|
*/
|
||
|
|
canRecognizeWith: function(otherRecognizer) {
|
||
|
|
return !!this.simultaneous[otherRecognizer.id];
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* You should use `tryEmit` instead of `emit` directly to check
|
||
|
|
* that all the needed recognizers has failed before emitting.
|
||
|
|
* @param {Object} input
|
||
|
|
*/
|
||
|
|
emit: function(input) {
|
||
|
|
var self = this;
|
||
|
|
var state = this.state;
|
||
|
|
|
||
|
|
function emit(event) {
|
||
|
|
self.manager.emit(event, input);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 'panstart' and 'panmove'
|
||
|
|
if (state < STATE_ENDED) {
|
||
|
|
emit(self.options.event + stateStr(state));
|
||
|
|
}
|
||
|
|
|
||
|
|
emit(self.options.event); // simple 'eventName' events
|
||
|
|
|
||
|
|
if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)
|
||
|
|
emit(input.additionalEvent);
|
||
|
|
}
|
||
|
|
|
||
|
|
// panend and pancancel
|
||
|
|
if (state >= STATE_ENDED) {
|
||
|
|
emit(self.options.event + stateStr(state));
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check that all the require failure recognizers has failed,
|
||
|
|
* if true, it emits a gesture event,
|
||
|
|
* otherwise, setup the state to FAILED.
|
||
|
|
* @param {Object} input
|
||
|
|
*/
|
||
|
|
tryEmit: function(input) {
|
||
|
|
if (this.canEmit()) {
|
||
|
|
return this.emit(input);
|
||
|
|
}
|
||
|
|
// it's failing anyway
|
||
|
|
this.state = STATE_FAILED;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* can we emit?
|
||
|
|
* @returns {boolean}
|
||
|
|
*/
|
||
|
|
canEmit: function() {
|
||
|
|
var i = 0;
|
||
|
|
while (i < this.requireFail.length) {
|
||
|
|
if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* update the recognizer
|
||
|
|
* @param {Object} inputData
|
||
|
|
*/
|
||
|
|
recognize: function(inputData) {
|
||
|
|
// make a new copy of the inputData
|
||
|
|
// so we can change the inputData without messing up the other recognizers
|
||
|
|
var inputDataClone = assign({}, inputData);
|
||
|
|
|
||
|
|
// is is enabled and allow recognizing?
|
||
|
|
if (!boolOrFn(this.options.enable, [this, inputDataClone])) {
|
||
|
|
this.reset();
|
||
|
|
this.state = STATE_FAILED;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// reset when we've reached the end
|
||
|
|
if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {
|
||
|
|
this.state = STATE_POSSIBLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.state = this.process(inputDataClone);
|
||
|
|
|
||
|
|
// the recognizer has recognized a gesture
|
||
|
|
// so trigger an event
|
||
|
|
if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {
|
||
|
|
this.tryEmit(inputDataClone);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* return the state of the recognizer
|
||
|
|
* the actual recognizing happens in this method
|
||
|
|
* @virtual
|
||
|
|
* @param {Object} inputData
|
||
|
|
* @returns {Const} STATE
|
||
|
|
*/
|
||
|
|
process: function(inputData) { }, // jshint ignore:line
|
||
|
|
|
||
|
|
/**
|
||
|
|
* return the preferred touch-action
|
||
|
|
* @virtual
|
||
|
|
* @returns {Array}
|
||
|
|
*/
|
||
|
|
getTouchAction: function() { },
|
||
|
|
|
||
|
|
/**
|
||
|
|
* called when the gesture isn't allowed to recognize
|
||
|
|
* like when another is being recognized or it is disabled
|
||
|
|
* @virtual
|
||
|
|
*/
|
||
|
|
reset: function() { }
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get a usable string, used as event postfix
|
||
|
|
* @param {Const} state
|
||
|
|
* @returns {String} state
|
||
|
|
*/
|
||
|
|
function stateStr(state) {
|
||
|
|
if (state & STATE_CANCELLED) {
|
||
|
|
return 'cancel';
|
||
|
|
} else if (state & STATE_ENDED) {
|
||
|
|
return 'end';
|
||
|
|
} else if (state & STATE_CHANGED) {
|
||
|
|
return 'move';
|
||
|
|
} else if (state & STATE_BEGAN) {
|
||
|
|
return 'start';
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* direction cons to string
|
||
|
|
* @param {Const} direction
|
||
|
|
* @returns {String}
|
||
|
|
*/
|
||
|
|
function directionStr(direction) {
|
||
|
|
if (direction == DIRECTION_DOWN) {
|
||
|
|
return 'down';
|
||
|
|
} else if (direction == DIRECTION_UP) {
|
||
|
|
return 'up';
|
||
|
|
} else if (direction == DIRECTION_LEFT) {
|
||
|
|
return 'left';
|
||
|
|
} else if (direction == DIRECTION_RIGHT) {
|
||
|
|
return 'right';
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get a recognizer by name if it is bound to a manager
|
||
|
|
* @param {Recognizer|String} otherRecognizer
|
||
|
|
* @param {Recognizer} recognizer
|
||
|
|
* @returns {Recognizer}
|
||
|
|
*/
|
||
|
|
function getRecognizerByNameIfManager(otherRecognizer, recognizer) {
|
||
|
|
var manager = recognizer.manager;
|
||
|
|
if (manager) {
|
||
|
|
return manager.get(otherRecognizer);
|
||
|
|
}
|
||
|
|
return otherRecognizer;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This recognizer is just used as a base for the simple attribute recognizers.
|
||
|
|
* @constructor
|
||
|
|
* @extends Recognizer
|
||
|
|
*/
|
||
|
|
function AttrRecognizer() {
|
||
|
|
Recognizer.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(AttrRecognizer, Recognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof AttrRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
/**
|
||
|
|
* @type {Number}
|
||
|
|
* @default 1
|
||
|
|
*/
|
||
|
|
pointers: 1
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Used to check if it the recognizer receives valid input, like input.distance > 10.
|
||
|
|
* @memberof AttrRecognizer
|
||
|
|
* @param {Object} input
|
||
|
|
* @returns {Boolean} recognized
|
||
|
|
*/
|
||
|
|
attrTest: function(input) {
|
||
|
|
var optionPointers = this.options.pointers;
|
||
|
|
return optionPointers === 0 || input.pointers.length === optionPointers;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Process the input and return the state for the recognizer
|
||
|
|
* @memberof AttrRecognizer
|
||
|
|
* @param {Object} input
|
||
|
|
* @returns {*} State
|
||
|
|
*/
|
||
|
|
process: function(input) {
|
||
|
|
var state = this.state;
|
||
|
|
var eventType = input.eventType;
|
||
|
|
|
||
|
|
var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
|
||
|
|
var isValid = this.attrTest(input);
|
||
|
|
|
||
|
|
// on cancel input and we've recognized before, return STATE_CANCELLED
|
||
|
|
if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
|
||
|
|
return state | STATE_CANCELLED;
|
||
|
|
} else if (isRecognized || isValid) {
|
||
|
|
if (eventType & INPUT_END) {
|
||
|
|
return state | STATE_ENDED;
|
||
|
|
} else if (!(state & STATE_BEGAN)) {
|
||
|
|
return STATE_BEGAN;
|
||
|
|
}
|
||
|
|
return state | STATE_CHANGED;
|
||
|
|
}
|
||
|
|
return STATE_FAILED;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Pan
|
||
|
|
* Recognized when the pointer is down and moved in the allowed direction.
|
||
|
|
* @constructor
|
||
|
|
* @extends AttrRecognizer
|
||
|
|
*/
|
||
|
|
function PanRecognizer() {
|
||
|
|
AttrRecognizer.apply(this, arguments);
|
||
|
|
|
||
|
|
this.pX = null;
|
||
|
|
this.pY = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(PanRecognizer, AttrRecognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof PanRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
event: 'pan',
|
||
|
|
threshold: 10,
|
||
|
|
pointers: 1,
|
||
|
|
direction: DIRECTION_ALL
|
||
|
|
},
|
||
|
|
|
||
|
|
getTouchAction: function() {
|
||
|
|
var direction = this.options.direction;
|
||
|
|
var actions = [];
|
||
|
|
if (direction & DIRECTION_HORIZONTAL) {
|
||
|
|
actions.push(TOUCH_ACTION_PAN_Y);
|
||
|
|
}
|
||
|
|
if (direction & DIRECTION_VERTICAL) {
|
||
|
|
actions.push(TOUCH_ACTION_PAN_X);
|
||
|
|
}
|
||
|
|
return actions;
|
||
|
|
},
|
||
|
|
|
||
|
|
directionTest: function(input) {
|
||
|
|
var options = this.options;
|
||
|
|
var hasMoved = true;
|
||
|
|
var distance = input.distance;
|
||
|
|
var direction = input.direction;
|
||
|
|
var x = input.deltaX;
|
||
|
|
var y = input.deltaY;
|
||
|
|
|
||
|
|
// lock to axis?
|
||
|
|
if (!(direction & options.direction)) {
|
||
|
|
if (options.direction & DIRECTION_HORIZONTAL) {
|
||
|
|
direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
|
||
|
|
hasMoved = x != this.pX;
|
||
|
|
distance = Math.abs(input.deltaX);
|
||
|
|
} else {
|
||
|
|
direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;
|
||
|
|
hasMoved = y != this.pY;
|
||
|
|
distance = Math.abs(input.deltaY);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
input.direction = direction;
|
||
|
|
return hasMoved && distance > options.threshold && direction & options.direction;
|
||
|
|
},
|
||
|
|
|
||
|
|
attrTest: function(input) {
|
||
|
|
return AttrRecognizer.prototype.attrTest.call(this, input) &&
|
||
|
|
(this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));
|
||
|
|
},
|
||
|
|
|
||
|
|
emit: function(input) {
|
||
|
|
|
||
|
|
this.pX = input.deltaX;
|
||
|
|
this.pY = input.deltaY;
|
||
|
|
|
||
|
|
var direction = directionStr(input.direction);
|
||
|
|
|
||
|
|
if (direction) {
|
||
|
|
input.additionalEvent = this.options.event + direction;
|
||
|
|
}
|
||
|
|
this._super.emit.call(this, input);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Pinch
|
||
|
|
* Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).
|
||
|
|
* @constructor
|
||
|
|
* @extends AttrRecognizer
|
||
|
|
*/
|
||
|
|
function PinchRecognizer() {
|
||
|
|
AttrRecognizer.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(PinchRecognizer, AttrRecognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof PinchRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
event: 'pinch',
|
||
|
|
threshold: 0,
|
||
|
|
pointers: 2
|
||
|
|
},
|
||
|
|
|
||
|
|
getTouchAction: function() {
|
||
|
|
return [TOUCH_ACTION_NONE];
|
||
|
|
},
|
||
|
|
|
||
|
|
attrTest: function(input) {
|
||
|
|
return this._super.attrTest.call(this, input) &&
|
||
|
|
(Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);
|
||
|
|
},
|
||
|
|
|
||
|
|
emit: function(input) {
|
||
|
|
if (input.scale !== 1) {
|
||
|
|
var inOut = input.scale < 1 ? 'in' : 'out';
|
||
|
|
input.additionalEvent = this.options.event + inOut;
|
||
|
|
}
|
||
|
|
this._super.emit.call(this, input);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Press
|
||
|
|
* Recognized when the pointer is down for x ms without any movement.
|
||
|
|
* @constructor
|
||
|
|
* @extends Recognizer
|
||
|
|
*/
|
||
|
|
function PressRecognizer() {
|
||
|
|
Recognizer.apply(this, arguments);
|
||
|
|
|
||
|
|
this._timer = null;
|
||
|
|
this._input = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(PressRecognizer, Recognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof PressRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
event: 'press',
|
||
|
|
pointers: 1,
|
||
|
|
time: 251, // minimal time of the pointer to be pressed
|
||
|
|
threshold: 9 // a minimal movement is ok, but keep it low
|
||
|
|
},
|
||
|
|
|
||
|
|
getTouchAction: function() {
|
||
|
|
return [TOUCH_ACTION_AUTO];
|
||
|
|
},
|
||
|
|
|
||
|
|
process: function(input) {
|
||
|
|
var options = this.options;
|
||
|
|
var validPointers = input.pointers.length === options.pointers;
|
||
|
|
var validMovement = input.distance < options.threshold;
|
||
|
|
var validTime = input.deltaTime > options.time;
|
||
|
|
|
||
|
|
this._input = input;
|
||
|
|
|
||
|
|
// we only allow little movement
|
||
|
|
// and we've reached an end event, so a tap is possible
|
||
|
|
if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {
|
||
|
|
this.reset();
|
||
|
|
} else if (input.eventType & INPUT_START) {
|
||
|
|
this.reset();
|
||
|
|
this._timer = setTimeoutContext(function() {
|
||
|
|
this.state = STATE_RECOGNIZED;
|
||
|
|
this.tryEmit();
|
||
|
|
}, options.time, this);
|
||
|
|
} else if (input.eventType & INPUT_END) {
|
||
|
|
return STATE_RECOGNIZED;
|
||
|
|
}
|
||
|
|
return STATE_FAILED;
|
||
|
|
},
|
||
|
|
|
||
|
|
reset: function() {
|
||
|
|
clearTimeout(this._timer);
|
||
|
|
},
|
||
|
|
|
||
|
|
emit: function(input) {
|
||
|
|
if (this.state !== STATE_RECOGNIZED) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (input && (input.eventType & INPUT_END)) {
|
||
|
|
this.manager.emit(this.options.event + 'up', input);
|
||
|
|
} else {
|
||
|
|
this._input.timeStamp = now();
|
||
|
|
this.manager.emit(this.options.event, this._input);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Rotate
|
||
|
|
* Recognized when two or more pointer are moving in a circular motion.
|
||
|
|
* @constructor
|
||
|
|
* @extends AttrRecognizer
|
||
|
|
*/
|
||
|
|
function RotateRecognizer() {
|
||
|
|
AttrRecognizer.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(RotateRecognizer, AttrRecognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof RotateRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
event: 'rotate',
|
||
|
|
threshold: 0,
|
||
|
|
pointers: 2
|
||
|
|
},
|
||
|
|
|
||
|
|
getTouchAction: function() {
|
||
|
|
return [TOUCH_ACTION_NONE];
|
||
|
|
},
|
||
|
|
|
||
|
|
attrTest: function(input) {
|
||
|
|
return this._super.attrTest.call(this, input) &&
|
||
|
|
(Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Swipe
|
||
|
|
* Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.
|
||
|
|
* @constructor
|
||
|
|
* @extends AttrRecognizer
|
||
|
|
*/
|
||
|
|
function SwipeRecognizer() {
|
||
|
|
AttrRecognizer.apply(this, arguments);
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(SwipeRecognizer, AttrRecognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof SwipeRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
event: 'swipe',
|
||
|
|
threshold: 10,
|
||
|
|
velocity: 0.3,
|
||
|
|
direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,
|
||
|
|
pointers: 1
|
||
|
|
},
|
||
|
|
|
||
|
|
getTouchAction: function() {
|
||
|
|
return PanRecognizer.prototype.getTouchAction.call(this);
|
||
|
|
},
|
||
|
|
|
||
|
|
attrTest: function(input) {
|
||
|
|
var direction = this.options.direction;
|
||
|
|
var velocity;
|
||
|
|
|
||
|
|
if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {
|
||
|
|
velocity = input.overallVelocity;
|
||
|
|
} else if (direction & DIRECTION_HORIZONTAL) {
|
||
|
|
velocity = input.overallVelocityX;
|
||
|
|
} else if (direction & DIRECTION_VERTICAL) {
|
||
|
|
velocity = input.overallVelocityY;
|
||
|
|
}
|
||
|
|
|
||
|
|
return this._super.attrTest.call(this, input) &&
|
||
|
|
direction & input.offsetDirection &&
|
||
|
|
input.distance > this.options.threshold &&
|
||
|
|
input.maxPointers == this.options.pointers &&
|
||
|
|
abs(velocity) > this.options.velocity && input.eventType & INPUT_END;
|
||
|
|
},
|
||
|
|
|
||
|
|
emit: function(input) {
|
||
|
|
var direction = directionStr(input.offsetDirection);
|
||
|
|
if (direction) {
|
||
|
|
this.manager.emit(this.options.event + direction, input);
|
||
|
|
}
|
||
|
|
|
||
|
|
this.manager.emit(this.options.event, input);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur
|
||
|
|
* between the given interval and position. The delay option can be used to recognize multi-taps without firing
|
||
|
|
* a single tap.
|
||
|
|
*
|
||
|
|
* The eventData from the emitted event contains the property `tapCount`, which contains the amount of
|
||
|
|
* multi-taps being recognized.
|
||
|
|
* @constructor
|
||
|
|
* @extends Recognizer
|
||
|
|
*/
|
||
|
|
function TapRecognizer() {
|
||
|
|
Recognizer.apply(this, arguments);
|
||
|
|
|
||
|
|
// previous time and center,
|
||
|
|
// used for tap counting
|
||
|
|
this.pTime = false;
|
||
|
|
this.pCenter = false;
|
||
|
|
|
||
|
|
this._timer = null;
|
||
|
|
this._input = null;
|
||
|
|
this.count = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
inherit(TapRecognizer, Recognizer, {
|
||
|
|
/**
|
||
|
|
* @namespace
|
||
|
|
* @memberof PinchRecognizer
|
||
|
|
*/
|
||
|
|
defaults: {
|
||
|
|
event: 'tap',
|
||
|
|
pointers: 1,
|
||
|
|
taps: 1,
|
||
|
|
interval: 300, // max time between the multi-tap taps
|
||
|
|
time: 250, // max time of the pointer to be down (like finger on the screen)
|
||
|
|
threshold: 9, // a minimal movement is ok, but keep it low
|
||
|
|
posThreshold: 10 // a multi-tap can be a bit off the initial position
|
||
|
|
},
|
||
|
|
|
||
|
|
getTouchAction: function() {
|
||
|
|
return [TOUCH_ACTION_MANIPULATION];
|
||
|
|
},
|
||
|
|
|
||
|
|
process: function(input) {
|
||
|
|
var options = this.options;
|
||
|
|
|
||
|
|
var validPointers = input.pointers.length === options.pointers;
|
||
|
|
var validMovement = input.distance < options.threshold;
|
||
|
|
var validTouchTime = input.deltaTime < options.time;
|
||
|
|
|
||
|
|
this.reset();
|
||
|
|
|
||
|
|
if ((input.eventType & INPUT_START) && (this.count === 0)) {
|
||
|
|
return this.failTimeout();
|
||
|
|
}
|
||
|
|
|
||
|
|
// we only allow little movement
|
||
|
|
// and we've reached an end event, so a tap is possible
|
||
|
|
if (validMovement && validTouchTime && validPointers) {
|
||
|
|
if (input.eventType != INPUT_END) {
|
||
|
|
return this.failTimeout();
|
||
|
|
}
|
||
|
|
|
||
|
|
var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;
|
||
|
|
var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;
|
||
|
|
|
||
|
|
this.pTime = input.timeStamp;
|
||
|
|
this.pCenter = input.center;
|
||
|
|
|
||
|
|
if (!validMultiTap || !validInterval) {
|
||
|
|
this.count = 1;
|
||
|
|
} else {
|
||
|
|
this.count += 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
this._input = input;
|
||
|
|
|
||
|
|
// if tap count matches we have recognized it,
|
||
|
|
// else it has began recognizing...
|
||
|
|
var tapCount = this.count % options.taps;
|
||
|
|
if (tapCount === 0) {
|
||
|
|
// no failing requirements, immediately trigger the tap event
|
||
|
|
// or wait as long as the multitap interval to trigger
|
||
|
|
if (!this.hasRequireFailures()) {
|
||
|
|
return STATE_RECOGNIZED;
|
||
|
|
} else {
|
||
|
|
this._timer = setTimeoutContext(function() {
|
||
|
|
this.state = STATE_RECOGNIZED;
|
||
|
|
this.tryEmit();
|
||
|
|
}, options.interval, this);
|
||
|
|
return STATE_BEGAN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return STATE_FAILED;
|
||
|
|
},
|
||
|
|
|
||
|
|
failTimeout: function() {
|
||
|
|
this._timer = setTimeoutContext(function() {
|
||
|
|
this.state = STATE_FAILED;
|
||
|
|
}, this.options.interval, this);
|
||
|
|
return STATE_FAILED;
|
||
|
|
},
|
||
|
|
|
||
|
|
reset: function() {
|
||
|
|
clearTimeout(this._timer);
|
||
|
|
},
|
||
|
|
|
||
|
|
emit: function() {
|
||
|
|
if (this.state == STATE_RECOGNIZED) {
|
||
|
|
this._input.tapCount = this.count;
|
||
|
|
this.manager.emit(this.options.event, this._input);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Simple way to create a manager with a default set of recognizers.
|
||
|
|
* @param {HTMLElement} element
|
||
|
|
* @param {Object} [options]
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
function Hammer(element, options) {
|
||
|
|
options = options || {};
|
||
|
|
options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);
|
||
|
|
return new Manager(element, options);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @const {string}
|
||
|
|
*/
|
||
|
|
Hammer.VERSION = '2.0.7';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* default settings
|
||
|
|
* @namespace
|
||
|
|
*/
|
||
|
|
Hammer.defaults = {
|
||
|
|
/**
|
||
|
|
* set if DOM events are being triggered.
|
||
|
|
* But this is slower and unused by simple implementations, so disabled by default.
|
||
|
|
* @type {Boolean}
|
||
|
|
* @default false
|
||
|
|
*/
|
||
|
|
domEvents: false,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The value for the touchAction property/fallback.
|
||
|
|
* When set to `compute` it will magically set the correct value based on the added recognizers.
|
||
|
|
* @type {String}
|
||
|
|
* @default compute
|
||
|
|
*/
|
||
|
|
touchAction: TOUCH_ACTION_COMPUTE,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @type {Boolean}
|
||
|
|
* @default true
|
||
|
|
*/
|
||
|
|
enable: true,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* EXPERIMENTAL FEATURE -- can be removed/changed
|
||
|
|
* Change the parent input target element.
|
||
|
|
* If Null, then it is being set the to main element.
|
||
|
|
* @type {Null|EventTarget}
|
||
|
|
* @default null
|
||
|
|
*/
|
||
|
|
inputTarget: null,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* force an input class
|
||
|
|
* @type {Null|Function}
|
||
|
|
* @default null
|
||
|
|
*/
|
||
|
|
inputClass: null,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Default recognizer setup when calling `Hammer()`
|
||
|
|
* When creating a new Manager these will be skipped.
|
||
|
|
* @type {Array}
|
||
|
|
*/
|
||
|
|
preset: [
|
||
|
|
// RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]
|
||
|
|
[RotateRecognizer, {enable: false}],
|
||
|
|
[PinchRecognizer, {enable: false}, ['rotate']],
|
||
|
|
[SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],
|
||
|
|
[PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],
|
||
|
|
[TapRecognizer],
|
||
|
|
[TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],
|
||
|
|
[PressRecognizer]
|
||
|
|
],
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Some CSS properties can be used to improve the working of Hammer.
|
||
|
|
* Add them to this method and they will be set when creating a new Manager.
|
||
|
|
* @namespace
|
||
|
|
*/
|
||
|
|
cssProps: {
|
||
|
|
/**
|
||
|
|
* Disables text selection to improve the dragging gesture. Mainly for desktop browsers.
|
||
|
|
* @type {String}
|
||
|
|
* @default 'none'
|
||
|
|
*/
|
||
|
|
userSelect: 'none',
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Disable the Windows Phone grippers when pressing an element.
|
||
|
|
* @type {String}
|
||
|
|
* @default 'none'
|
||
|
|
*/
|
||
|
|
touchSelect: 'none',
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Disables the default callout shown when you touch and hold a touch target.
|
||
|
|
* On iOS, when you touch and hold a touch target such as a link, Safari displays
|
||
|
|
* a callout containing information about the link. This property allows you to disable that callout.
|
||
|
|
* @type {String}
|
||
|
|
* @default 'none'
|
||
|
|
*/
|
||
|
|
touchCallout: 'none',
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Specifies whether zooming is enabled. Used by IE10>
|
||
|
|
* @type {String}
|
||
|
|
* @default 'none'
|
||
|
|
*/
|
||
|
|
contentZooming: 'none',
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.
|
||
|
|
* @type {String}
|
||
|
|
* @default 'none'
|
||
|
|
*/
|
||
|
|
userDrag: 'none',
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Overrides the highlight color shown when the user taps a link or a JavaScript
|
||
|
|
* clickable element in iOS. This property obeys the alpha value, if specified.
|
||
|
|
* @type {String}
|
||
|
|
* @default 'rgba(0,0,0,0)'
|
||
|
|
*/
|
||
|
|
tapHighlightColor: 'rgba(0,0,0,0)'
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var STOP = 1;
|
||
|
|
var FORCED_STOP = 2;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Manager
|
||
|
|
* @param {HTMLElement} element
|
||
|
|
* @param {Object} [options]
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
function Manager(element, options) {
|
||
|
|
this.options = assign({}, Hammer.defaults, options || {});
|
||
|
|
|
||
|
|
this.options.inputTarget = this.options.inputTarget || element;
|
||
|
|
|
||
|
|
this.handlers = {};
|
||
|
|
this.session = {};
|
||
|
|
this.recognizers = [];
|
||
|
|
this.oldCssProps = {};
|
||
|
|
|
||
|
|
this.element = element;
|
||
|
|
this.input = createInputInstance(this);
|
||
|
|
this.touchAction = new TouchAction(this, this.options.touchAction);
|
||
|
|
|
||
|
|
toggleCssProps(this, true);
|
||
|
|
|
||
|
|
each(this.options.recognizers, function(item) {
|
||
|
|
var recognizer = this.add(new (item[0])(item[1]));
|
||
|
|
item[2] && recognizer.recognizeWith(item[2]);
|
||
|
|
item[3] && recognizer.requireFailure(item[3]);
|
||
|
|
}, this);
|
||
|
|
}
|
||
|
|
|
||
|
|
Manager.prototype = {
|
||
|
|
/**
|
||
|
|
* set options
|
||
|
|
* @param {Object} options
|
||
|
|
* @returns {Manager}
|
||
|
|
*/
|
||
|
|
set: function(options) {
|
||
|
|
assign(this.options, options);
|
||
|
|
|
||
|
|
// Options that need a little more setup
|
||
|
|
if (options.touchAction) {
|
||
|
|
this.touchAction.update();
|
||
|
|
}
|
||
|
|
if (options.inputTarget) {
|
||
|
|
// Clean up existing event listeners and reinitialize
|
||
|
|
this.input.destroy();
|
||
|
|
this.input.target = options.inputTarget;
|
||
|
|
this.input.init();
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* stop recognizing for this session.
|
||
|
|
* This session will be discarded, when a new [input]start event is fired.
|
||
|
|
* When forced, the recognizer cycle is stopped immediately.
|
||
|
|
* @param {Boolean} [force]
|
||
|
|
*/
|
||
|
|
stop: function(force) {
|
||
|
|
this.session.stopped = force ? FORCED_STOP : STOP;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* run the recognizers!
|
||
|
|
* called by the inputHandler function on every movement of the pointers (touches)
|
||
|
|
* it walks through all the recognizers and tries to detect the gesture that is being made
|
||
|
|
* @param {Object} inputData
|
||
|
|
*/
|
||
|
|
recognize: function(inputData) {
|
||
|
|
var session = this.session;
|
||
|
|
if (session.stopped) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// run the touch-action polyfill
|
||
|
|
this.touchAction.preventDefaults(inputData);
|
||
|
|
|
||
|
|
var recognizer;
|
||
|
|
var recognizers = this.recognizers;
|
||
|
|
|
||
|
|
// this holds the recognizer that is being recognized.
|
||
|
|
// so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
|
||
|
|
// if no recognizer is detecting a thing, it is set to `null`
|
||
|
|
var curRecognizer = session.curRecognizer;
|
||
|
|
|
||
|
|
// reset when the last recognizer is recognized
|
||
|
|
// or when we're in a new session
|
||
|
|
if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
|
||
|
|
curRecognizer = session.curRecognizer = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
var i = 0;
|
||
|
|
while (i < recognizers.length) {
|
||
|
|
recognizer = recognizers[i];
|
||
|
|
|
||
|
|
// find out if we are allowed try to recognize the input for this one.
|
||
|
|
// 1. allow if the session is NOT forced stopped (see the .stop() method)
|
||
|
|
// 2. allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
|
||
|
|
// that is being recognized.
|
||
|
|
// 3. allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
|
||
|
|
// this can be setup with the `recognizeWith()` method on the recognizer.
|
||
|
|
if (session.stopped !== FORCED_STOP && ( // 1
|
||
|
|
!curRecognizer || recognizer == curRecognizer || // 2
|
||
|
|
recognizer.canRecognizeWith(curRecognizer))) { // 3
|
||
|
|
recognizer.recognize(inputData);
|
||
|
|
} else {
|
||
|
|
recognizer.reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
// if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
|
||
|
|
// current active recognizer. but only if we don't already have an active recognizer
|
||
|
|
if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
|
||
|
|
curRecognizer = session.curRecognizer = recognizer;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* get a recognizer by its event name.
|
||
|
|
* @param {Recognizer|String} recognizer
|
||
|
|
* @returns {Recognizer|Null}
|
||
|
|
*/
|
||
|
|
get: function(recognizer) {
|
||
|
|
if (recognizer instanceof Recognizer) {
|
||
|
|
return recognizer;
|
||
|
|
}
|
||
|
|
|
||
|
|
var recognizers = this.recognizers;
|
||
|
|
for (var i = 0; i < recognizers.length; i++) {
|
||
|
|
if (recognizers[i].options.event == recognizer) {
|
||
|
|
return recognizers[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* add a recognizer to the manager
|
||
|
|
* existing recognizers with the same event name will be removed
|
||
|
|
* @param {Recognizer} recognizer
|
||
|
|
* @returns {Recognizer|Manager}
|
||
|
|
*/
|
||
|
|
add: function(recognizer) {
|
||
|
|
if (invokeArrayArg(recognizer, 'add', this)) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
// remove existing
|
||
|
|
var existing = this.get(recognizer.options.event);
|
||
|
|
if (existing) {
|
||
|
|
this.remove(existing);
|
||
|
|
}
|
||
|
|
|
||
|
|
this.recognizers.push(recognizer);
|
||
|
|
recognizer.manager = this;
|
||
|
|
|
||
|
|
this.touchAction.update();
|
||
|
|
return recognizer;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* remove a recognizer by name or instance
|
||
|
|
* @param {Recognizer|String} recognizer
|
||
|
|
* @returns {Manager}
|
||
|
|
*/
|
||
|
|
remove: function(recognizer) {
|
||
|
|
if (invokeArrayArg(recognizer, 'remove', this)) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
recognizer = this.get(recognizer);
|
||
|
|
|
||
|
|
// let's make sure this recognizer exists
|
||
|
|
if (recognizer) {
|
||
|
|
var recognizers = this.recognizers;
|
||
|
|
var index = inArray(recognizers, recognizer);
|
||
|
|
|
||
|
|
if (index !== -1) {
|
||
|
|
recognizers.splice(index, 1);
|
||
|
|
this.touchAction.update();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* bind event
|
||
|
|
* @param {String} events
|
||
|
|
* @param {Function} handler
|
||
|
|
* @returns {EventEmitter} this
|
||
|
|
*/
|
||
|
|
on: function(events, handler) {
|
||
|
|
if (events === undefined) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (handler === undefined) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var handlers = this.handlers;
|
||
|
|
each(splitStr(events), function(event) {
|
||
|
|
handlers[event] = handlers[event] || [];
|
||
|
|
handlers[event].push(handler);
|
||
|
|
});
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* unbind event, leave emit blank to remove all handlers
|
||
|
|
* @param {String} events
|
||
|
|
* @param {Function} [handler]
|
||
|
|
* @returns {EventEmitter} this
|
||
|
|
*/
|
||
|
|
off: function(events, handler) {
|
||
|
|
if (events === undefined) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var handlers = this.handlers;
|
||
|
|
each(splitStr(events), function(event) {
|
||
|
|
if (!handler) {
|
||
|
|
delete handlers[event];
|
||
|
|
} else {
|
||
|
|
handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* emit event to the listeners
|
||
|
|
* @param {String} event
|
||
|
|
* @param {Object} data
|
||
|
|
*/
|
||
|
|
emit: function(event, data) {
|
||
|
|
// we also want to trigger dom events
|
||
|
|
if (this.options.domEvents) {
|
||
|
|
triggerDomEvent(event, data);
|
||
|
|
}
|
||
|
|
|
||
|
|
// no handlers, so skip it all
|
||
|
|
var handlers = this.handlers[event] && this.handlers[event].slice();
|
||
|
|
if (!handlers || !handlers.length) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
data.type = event;
|
||
|
|
data.preventDefault = function() {
|
||
|
|
data.srcEvent.preventDefault();
|
||
|
|
};
|
||
|
|
|
||
|
|
var i = 0;
|
||
|
|
while (i < handlers.length) {
|
||
|
|
handlers[i](data);
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* destroy the manager and unbinds all events
|
||
|
|
* it doesn't unbind dom events, that is the user own responsibility
|
||
|
|
*/
|
||
|
|
destroy: function() {
|
||
|
|
this.element && toggleCssProps(this, false);
|
||
|
|
|
||
|
|
this.handlers = {};
|
||
|
|
this.session = {};
|
||
|
|
this.input.destroy();
|
||
|
|
this.element = null;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* add/remove the css properties as defined in manager.options.cssProps
|
||
|
|
* @param {Manager} manager
|
||
|
|
* @param {Boolean} add
|
||
|
|
*/
|
||
|
|
function toggleCssProps(manager, add) {
|
||
|
|
var element = manager.element;
|
||
|
|
if (!element.style) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var prop;
|
||
|
|
each(manager.options.cssProps, function(value, name) {
|
||
|
|
prop = prefixed(element.style, name);
|
||
|
|
if (add) {
|
||
|
|
manager.oldCssProps[prop] = element.style[prop];
|
||
|
|
element.style[prop] = value;
|
||
|
|
} else {
|
||
|
|
element.style[prop] = manager.oldCssProps[prop] || '';
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if (!add) {
|
||
|
|
manager.oldCssProps = {};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* trigger dom event
|
||
|
|
* @param {String} event
|
||
|
|
* @param {Object} data
|
||
|
|
*/
|
||
|
|
function triggerDomEvent(event, data) {
|
||
|
|
var gestureEvent = document.createEvent('Event');
|
||
|
|
gestureEvent.initEvent(event, true, true);
|
||
|
|
gestureEvent.gesture = data;
|
||
|
|
data.target.dispatchEvent(gestureEvent);
|
||
|
|
}
|
||
|
|
|
||
|
|
assign(Hammer, {
|
||
|
|
INPUT_START: INPUT_START,
|
||
|
|
INPUT_MOVE: INPUT_MOVE,
|
||
|
|
INPUT_END: INPUT_END,
|
||
|
|
INPUT_CANCEL: INPUT_CANCEL,
|
||
|
|
|
||
|
|
STATE_POSSIBLE: STATE_POSSIBLE,
|
||
|
|
STATE_BEGAN: STATE_BEGAN,
|
||
|
|
STATE_CHANGED: STATE_CHANGED,
|
||
|
|
STATE_ENDED: STATE_ENDED,
|
||
|
|
STATE_RECOGNIZED: STATE_RECOGNIZED,
|
||
|
|
STATE_CANCELLED: STATE_CANCELLED,
|
||
|
|
STATE_FAILED: STATE_FAILED,
|
||
|
|
|
||
|
|
DIRECTION_NONE: DIRECTION_NONE,
|
||
|
|
DIRECTION_LEFT: DIRECTION_LEFT,
|
||
|
|
DIRECTION_RIGHT: DIRECTION_RIGHT,
|
||
|
|
DIRECTION_UP: DIRECTION_UP,
|
||
|
|
DIRECTION_DOWN: DIRECTION_DOWN,
|
||
|
|
DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
|
||
|
|
DIRECTION_VERTICAL: DIRECTION_VERTICAL,
|
||
|
|
DIRECTION_ALL: DIRECTION_ALL,
|
||
|
|
|
||
|
|
Manager: Manager,
|
||
|
|
Input: Input,
|
||
|
|
TouchAction: TouchAction,
|
||
|
|
|
||
|
|
TouchInput: TouchInput,
|
||
|
|
MouseInput: MouseInput,
|
||
|
|
PointerEventInput: PointerEventInput,
|
||
|
|
TouchMouseInput: TouchMouseInput,
|
||
|
|
SingleTouchInput: SingleTouchInput,
|
||
|
|
|
||
|
|
Recognizer: Recognizer,
|
||
|
|
AttrRecognizer: AttrRecognizer,
|
||
|
|
Tap: TapRecognizer,
|
||
|
|
Pan: PanRecognizer,
|
||
|
|
Swipe: SwipeRecognizer,
|
||
|
|
Pinch: PinchRecognizer,
|
||
|
|
Rotate: RotateRecognizer,
|
||
|
|
Press: PressRecognizer,
|
||
|
|
|
||
|
|
on: addEventListeners,
|
||
|
|
off: removeEventListeners,
|
||
|
|
each: each,
|
||
|
|
merge: merge,
|
||
|
|
extend: extend,
|
||
|
|
assign: assign,
|
||
|
|
inherit: inherit,
|
||
|
|
bindFn: bindFn,
|
||
|
|
prefixed: prefixed
|
||
|
|
});
|
||
|
|
|
||
|
|
// this prevents errors when Hammer is loaded in the presence of an AMD
|
||
|
|
// style loader but by script tag, not by the loader.
|
||
|
|
var freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line
|
||
|
|
freeGlobal.Hammer = Hammer;
|
||
|
|
|
||
|
|
if (true) {
|
||
|
|
!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
|
||
|
|
return Hammer;
|
||
|
|
}).call(exports, __webpack_require__, exports, module),
|
||
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
||
|
|
} else {}
|
||
|
|
|
||
|
|
})(window, document, 'Hammer');
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./src/example.scss":
|
||
|
|
/*!**************************!*\
|
||
|
|
!*** ./src/example.scss ***!
|
||
|
|
\**************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
// extracted by mini-css-extract-plugin
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/__.js":
|
||
|
|
/*!*****************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/__.js ***!
|
||
|
|
\*****************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "__": () => (/* binding */ __)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_binding_types_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/binding-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/binding-types.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_expression_types_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../node_modules/@riotjs/util/expression-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/expression-types.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js */ "./node_modules/riot/esm/node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js");
|
||
|
|
/* harmony import */ var _core_css_manager_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/css-manager.js */ "./node_modules/riot/esm/core/css-manager.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// expose some internal stuff that might be used from external tools
|
||
|
|
const __ = {
|
||
|
|
cssManager: _core_css_manager_js__WEBPACK_IMPORTED_MODULE_0__["default"],
|
||
|
|
DOMBindings: {
|
||
|
|
template: _node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_1__.template,
|
||
|
|
createBinding: _node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_1__.createBinding,
|
||
|
|
createExpression: _node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_1__.createExpression,
|
||
|
|
bindingTypes: _node_modules_riotjs_util_binding_types_js__WEBPACK_IMPORTED_MODULE_2__["default"],
|
||
|
|
expressionTypes: _node_modules_riotjs_util_expression_types_js__WEBPACK_IMPORTED_MODULE_3__["default"]
|
||
|
|
},
|
||
|
|
globals: {
|
||
|
|
DOM_COMPONENT_INSTANCE_PROPERTY: _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.DOM_COMPONENT_INSTANCE_PROPERTY,
|
||
|
|
PARENT_KEY_SYMBOL: _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PARENT_KEY_SYMBOL
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/component.js":
|
||
|
|
/*!************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/component.js ***!
|
||
|
|
\************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "component": () => (/* binding */ component)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_cumpa_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/cumpa/index.next.js */ "./node_modules/riot/esm/node_modules/cumpa/index.next.js");
|
||
|
|
/* harmony import */ var _core_create_component_from_wrapper_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/create-component-from-wrapper.js */ "./node_modules/riot/esm/core/create-component-from-wrapper.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Helper method to create component without relying on the registered ones
|
||
|
|
* @param {Object} implementation - component implementation
|
||
|
|
* @returns {Function} function that will allow you to mount a riot component on a DOM node
|
||
|
|
*/
|
||
|
|
function component(implementation) {
|
||
|
|
return function (el, props, _temp) {
|
||
|
|
let {
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
parentScope
|
||
|
|
} = _temp === void 0 ? {} : _temp;
|
||
|
|
return (0,_node_modules_cumpa_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(c => c.mount(el, parentScope), c => c({
|
||
|
|
props,
|
||
|
|
slots,
|
||
|
|
attributes
|
||
|
|
}), _core_create_component_from_wrapper_js__WEBPACK_IMPORTED_MODULE_1__.createComponentFromWrapper)(implementation);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/install.js":
|
||
|
|
/*!**********************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/install.js ***!
|
||
|
|
\**********************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "install": () => (/* binding */ install)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/checks.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/checks.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Define a riot plugin
|
||
|
|
* @param {Function} plugin - function that will receive all the components created
|
||
|
|
* @returns {Set} the set containing all the plugins installed
|
||
|
|
*/
|
||
|
|
function install(plugin) {
|
||
|
|
if (!(0,_node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_0__.isFunction)(plugin)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__.panic)('Plugins must be of type function');
|
||
|
|
if (_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.PLUGINS_SET.has(plugin)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__.panic)('This plugin was already installed');
|
||
|
|
_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.PLUGINS_SET.add(plugin);
|
||
|
|
return _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.PLUGINS_SET;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/mount.js":
|
||
|
|
/*!********************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/mount.js ***!
|
||
|
|
\********************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "mount": () => (/* binding */ mount)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/bianco.query/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.query/index.next.js");
|
||
|
|
/* harmony import */ var _core_mount_component_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/mount-component.js */ "./node_modules/riot/esm/core/mount-component.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Mounting function that will work only for the components that were globally registered
|
||
|
|
* @param {string|HTMLElement} selector - query for the selection or a DOM element
|
||
|
|
* @param {Object} initialProps - the initial component properties
|
||
|
|
* @param {string} name - optional component name
|
||
|
|
* @returns {Array} list of riot components
|
||
|
|
*/
|
||
|
|
function mount(selector, initialProps, name) {
|
||
|
|
return (0,_node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(selector).map(element => (0,_core_mount_component_js__WEBPACK_IMPORTED_MODULE_1__.mountComponent)(element, initialProps, name));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/pure.js":
|
||
|
|
/*!*******************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/pure.js ***!
|
||
|
|
\*******************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "pure": () => (/* binding */ pure)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/checks.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/checks.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Lift a riot component Interface into a pure riot object
|
||
|
|
* @param {Function} func - RiotPureComponent factory function
|
||
|
|
* @returns {Function} the lifted original function received as argument
|
||
|
|
*/
|
||
|
|
function pure(func) {
|
||
|
|
if (!(0,_node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_0__.isFunction)(func)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__.panic)('riot.pure accepts only arguments of type "function"');
|
||
|
|
func[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.IS_PURE_SYMBOL] = true;
|
||
|
|
return func;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/register.js":
|
||
|
|
/*!***********************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/register.js ***!
|
||
|
|
\***********************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "register": () => (/* binding */ register)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* harmony import */ var _core_create_component_from_wrapper_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/create-component-from-wrapper.js */ "./node_modules/riot/esm/core/create-component-from-wrapper.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Register a custom tag by name
|
||
|
|
* @param {string} name - component name
|
||
|
|
* @param {Object} implementation - tag implementation
|
||
|
|
* @returns {Map} map containing all the components implementations
|
||
|
|
*/
|
||
|
|
function register(name, _ref) {
|
||
|
|
let {
|
||
|
|
css,
|
||
|
|
template,
|
||
|
|
exports
|
||
|
|
} = _ref;
|
||
|
|
if (_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.COMPONENTS_IMPLEMENTATION_MAP.has(name)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__.panic)(`The component "${name}" was already registered`);
|
||
|
|
_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.COMPONENTS_IMPLEMENTATION_MAP.set(name, (0,_core_create_component_from_wrapper_js__WEBPACK_IMPORTED_MODULE_2__.createComponentFromWrapper)({
|
||
|
|
name,
|
||
|
|
css,
|
||
|
|
template,
|
||
|
|
exports
|
||
|
|
}));
|
||
|
|
return _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.COMPONENTS_IMPLEMENTATION_MAP;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/uninstall.js":
|
||
|
|
/*!************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/uninstall.js ***!
|
||
|
|
\************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "uninstall": () => (/* binding */ uninstall)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Uninstall a riot plugin
|
||
|
|
* @param {Function} plugin - plugin previously installed
|
||
|
|
* @returns {Set} the set containing all the plugins installed
|
||
|
|
*/
|
||
|
|
function uninstall(plugin) {
|
||
|
|
if (!_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.PLUGINS_SET.has(plugin)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__.panic)('This plugin was never installed');
|
||
|
|
_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.PLUGINS_SET["delete"](plugin);
|
||
|
|
return _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.PLUGINS_SET;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/unmount.js":
|
||
|
|
/*!**********************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/unmount.js ***!
|
||
|
|
\**********************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "unmount": () => (/* binding */ unmount)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/bianco.query/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.query/index.next.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sweet unmounting helper function for the DOM node mounted manually by the user
|
||
|
|
* @param {string|HTMLElement} selector - query for the selection or a DOM element
|
||
|
|
* @param {boolean|null} keepRootElement - if true keep the root element
|
||
|
|
* @returns {Array} list of nodes unmounted
|
||
|
|
*/
|
||
|
|
function unmount(selector, keepRootElement) {
|
||
|
|
return (0,_node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(selector).map(element => {
|
||
|
|
if (element[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__.DOM_COMPONENT_INSTANCE_PROPERTY]) {
|
||
|
|
element[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__.DOM_COMPONENT_INSTANCE_PROPERTY].unmount(keepRootElement);
|
||
|
|
}
|
||
|
|
return element;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/unregister.js":
|
||
|
|
/*!*************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/unregister.js ***!
|
||
|
|
\*************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "unregister": () => (/* binding */ unregister)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* harmony import */ var _core_css_manager_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/css-manager.js */ "./node_modules/riot/esm/core/css-manager.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Unregister a riot web component
|
||
|
|
* @param {string} name - component name
|
||
|
|
* @returns {Map} map containing all the components implementations
|
||
|
|
*/
|
||
|
|
function unregister(name) {
|
||
|
|
if (!_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.COMPONENTS_IMPLEMENTATION_MAP.has(name)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_1__.panic)(`The component "${name}" was never registered`);
|
||
|
|
_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.COMPONENTS_IMPLEMENTATION_MAP["delete"](name);
|
||
|
|
_core_css_manager_js__WEBPACK_IMPORTED_MODULE_2__["default"].remove(name);
|
||
|
|
return _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.COMPONENTS_IMPLEMENTATION_MAP;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/version.js":
|
||
|
|
/*!**********************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/version.js ***!
|
||
|
|
\**********************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "version": () => (/* binding */ version)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
/** @type {string} current riot version */
|
||
|
|
const version = 'v7.1.0';
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/api/with-types.js":
|
||
|
|
/*!*************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/api/with-types.js ***!
|
||
|
|
\*************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "withTypes": () => (/* binding */ withTypes)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
/**
|
||
|
|
* no-op function needed to add the proper types to your component via typescript
|
||
|
|
* @param {Function|Object} component - component default export
|
||
|
|
* @returns {Function|Object} returns exactly what it has received
|
||
|
|
*/
|
||
|
|
/* istanbul ignore next */
|
||
|
|
const withTypes = component => component;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/add-css-hook.js":
|
||
|
|
/*!****************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/add-css-hook.js ***!
|
||
|
|
\****************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "addCssHook": () => (/* binding */ addCssHook)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _utils_dom_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/dom.js */ "./node_modules/riot/esm/utils/dom.js");
|
||
|
|
/* harmony import */ var _node_modules_bianco_attr_index_next_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/bianco.attr/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.attr/index.next.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Add eventually the "is" attribute to link this DOM node to its css
|
||
|
|
* @param {HTMLElement} element - target root node
|
||
|
|
* @param {string} name - name of the component mounted
|
||
|
|
* @returns {undefined} it's a void function
|
||
|
|
*/
|
||
|
|
|
||
|
|
function addCssHook(element, name) {
|
||
|
|
if ((0,_utils_dom_js__WEBPACK_IMPORTED_MODULE_0__.getName)(element) !== name) {
|
||
|
|
(0,_node_modules_bianco_attr_index_next_js__WEBPACK_IMPORTED_MODULE_1__.set)(element, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.IS_DIRECTIVE, name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/bind-dom-node-to-component-instance.js":
|
||
|
|
/*!***************************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/bind-dom-node-to-component-instance.js ***!
|
||
|
|
\***************************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "bindDOMNodeToComponentInstance": () => (/* binding */ bindDOMNodeToComponentInstance)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Bind a DOM node to its component object
|
||
|
|
* @param {HTMLElement} node - html node mounted
|
||
|
|
* @param {Object} component - Riot.js component object
|
||
|
|
* @returns {Object} the component object received as second argument
|
||
|
|
*/
|
||
|
|
const bindDOMNodeToComponentInstance = (node, component) => node[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.DOM_COMPONENT_INSTANCE_PROPERTY] = component;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/component-dom-selectors.js":
|
||
|
|
/*!***************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/component-dom-selectors.js ***!
|
||
|
|
\***************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "COMPONENT_DOM_SELECTORS": () => (/* binding */ COMPONENT_DOM_SELECTORS)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/bianco.query/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.query/index.next.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
const COMPONENT_DOM_SELECTORS = Object.freeze({
|
||
|
|
// component helpers
|
||
|
|
$(selector) {
|
||
|
|
return (0,_node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(selector, this.root)[0];
|
||
|
|
},
|
||
|
|
$$(selector) {
|
||
|
|
return (0,_node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(selector, this.root);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/component-lifecycle-methods.js":
|
||
|
|
/*!*******************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/component-lifecycle-methods.js ***!
|
||
|
|
\*******************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "COMPONENT_LIFECYCLE_METHODS": () => (/* binding */ COMPONENT_LIFECYCLE_METHODS)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
const COMPONENT_LIFECYCLE_METHODS = Object.freeze({
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.SHOULD_UPDATE_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.ON_BEFORE_MOUNT_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.ON_MOUNTED_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.ON_BEFORE_UPDATE_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.ON_UPDATED_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.ON_BEFORE_UNMOUNT_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.ON_UNMOUNTED_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/component-template-factory.js":
|
||
|
|
/*!******************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/component-template-factory.js ***!
|
||
|
|
\******************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "componentTemplateFactory": () => (/* binding */ componentTemplateFactory)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js */ "./node_modules/riot/esm/node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/expression-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/expression-types.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_binding_types_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/binding-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/binding-types.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Factory function to create the component templates only once
|
||
|
|
* @param {Function} template - component template creation function
|
||
|
|
* @param {RiotComponentWrapper} componentWrapper - riot compiler generated object
|
||
|
|
* @param {Function} getChildComponent - getter function to return the children components
|
||
|
|
* @returns {TemplateChunk} template chunk object
|
||
|
|
*/
|
||
|
|
function componentTemplateFactory(template, componentWrapper, getChildComponent) {
|
||
|
|
return template(_node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_0__.template, _node_modules_riotjs_util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__["default"], _node_modules_riotjs_util_binding_types_js__WEBPACK_IMPORTED_MODULE_2__["default"], getChildComponent);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/compute-component-state.js":
|
||
|
|
/*!***************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/compute-component-state.js ***!
|
||
|
|
\***************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "computeComponentState": () => (/* binding */ computeComponentState)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Compute the component current state merging it with its previous state
|
||
|
|
* @param {Object} oldState - previous state object
|
||
|
|
* @param {Object} newState - new state given to the `update` call
|
||
|
|
* @returns {Object} new object state
|
||
|
|
*/
|
||
|
|
function computeComponentState(oldState, newState) {
|
||
|
|
return Object.assign({}, oldState, (0,_node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__.callOrAssign)(newState));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/compute-initial-props.js":
|
||
|
|
/*!*************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/compute-initial-props.js ***!
|
||
|
|
\*************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "computeInitialProps": () => (/* binding */ computeInitialProps)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_dom_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/dom.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/dom.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Evaluate the component properties either from its real attributes or from its initial user properties
|
||
|
|
* @param {HTMLElement} element - component root
|
||
|
|
* @param {Object} initialProps - initial props
|
||
|
|
* @returns {Object} component props key value pairs
|
||
|
|
*/
|
||
|
|
function computeInitialProps(element, initialProps) {
|
||
|
|
if (initialProps === void 0) {
|
||
|
|
initialProps = {};
|
||
|
|
}
|
||
|
|
return Object.assign({}, (0,_node_modules_riotjs_util_dom_js__WEBPACK_IMPORTED_MODULE_0__.DOMattributesToObject)(element), (0,_node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.callOrAssign)(initialProps));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/create-attribute-bindings.js":
|
||
|
|
/*!*****************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/create-attribute-bindings.js ***!
|
||
|
|
\*****************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "createAttributeBindings": () => (/* binding */ createAttributeBindings)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _create_core_api_methods_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./create-core-api-methods.js */ "./node_modules/riot/esm/core/create-core-api-methods.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js */ "./node_modules/riot/esm/node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the bindings to update the component attributes
|
||
|
|
* @param {HTMLElement} node - node where we will bind the expressions
|
||
|
|
* @param {Array} attributes - list of attribute bindings
|
||
|
|
* @returns {TemplateChunk} - template bindings object
|
||
|
|
*/
|
||
|
|
function createAttributeBindings(node, attributes) {
|
||
|
|
if (attributes === void 0) {
|
||
|
|
attributes = [];
|
||
|
|
}
|
||
|
|
const expressions = attributes.map(a => (0,_node_modules_riotjs_dom_bindings_dist_esm_dom_bindings_js__WEBPACK_IMPORTED_MODULE_0__.createExpression)(node, a));
|
||
|
|
const binding = {};
|
||
|
|
return Object.assign(binding, Object.assign({
|
||
|
|
expressions
|
||
|
|
}, (0,_create_core_api_methods_js__WEBPACK_IMPORTED_MODULE_1__.createCoreAPIMethods)(method => scope => {
|
||
|
|
expressions.forEach(e => e[method](scope));
|
||
|
|
return binding;
|
||
|
|
})));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/create-component-from-wrapper.js":
|
||
|
|
/*!*********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/create-component-from-wrapper.js ***!
|
||
|
|
\*********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "createComponentFromWrapper": () => (/* binding */ createComponentFromWrapper)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_strings_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/strings.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/strings.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* harmony import */ var _mocked_template_interface_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./mocked-template-interface.js */ "./node_modules/riot/esm/core/mocked-template-interface.js");
|
||
|
|
/* harmony import */ var _component_template_factory_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./component-template-factory.js */ "./node_modules/riot/esm/core/component-template-factory.js");
|
||
|
|
/* harmony import */ var _create_pure_component_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./create-pure-component.js */ "./node_modules/riot/esm/core/create-pure-component.js");
|
||
|
|
/* harmony import */ var _instantiate_component_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./instantiate-component.js */ "./node_modules/riot/esm/core/instantiate-component.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the subcomponents that can be included inside a tag in runtime
|
||
|
|
* @param {Object} components - components imported in runtime
|
||
|
|
* @returns {Object} all the components transformed into Riot.Component factory functions
|
||
|
|
*/
|
||
|
|
function createChildrenComponentsObject(components) {
|
||
|
|
if (components === void 0) {
|
||
|
|
components = {};
|
||
|
|
}
|
||
|
|
return Object.entries((0,_node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__.callOrAssign)(components)).reduce((acc, _ref) => {
|
||
|
|
let [key, value] = _ref;
|
||
|
|
acc[(0,_node_modules_riotjs_util_strings_js__WEBPACK_IMPORTED_MODULE_1__.camelToDashCase)(key)] = createComponentFromWrapper(value);
|
||
|
|
return acc;
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the getter function to render the child components
|
||
|
|
* @param {RiotComponentWrapper} componentWrapper - riot compiler generated object
|
||
|
|
* @returns {Function} function returning the component factory function
|
||
|
|
*/
|
||
|
|
const createChildComponentGetter = componentWrapper => {
|
||
|
|
const childrenComponents = createChildrenComponentsObject(componentWrapper.exports ? componentWrapper.exports.components : {});
|
||
|
|
return name => {
|
||
|
|
// improve support for recursive components
|
||
|
|
if (name === componentWrapper.name) return memoizedCreateComponentFromWrapper(componentWrapper);
|
||
|
|
// return the registered components
|
||
|
|
return childrenComponents[name] || _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.COMPONENTS_IMPLEMENTATION_MAP.get(name);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Performance optimization for the recursive components
|
||
|
|
* @param {RiotComponentWrapper} componentWrapper - riot compiler generated object
|
||
|
|
* @returns {Object} component like interface
|
||
|
|
*/
|
||
|
|
const memoizedCreateComponentFromWrapper = (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_3__.memoize)(createComponentFromWrapper);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the component interface needed for the @riotjs/dom-bindings tag bindings
|
||
|
|
* @param {RiotComponentWrapper} componentWrapper - riot compiler generated object
|
||
|
|
* @param {string} componentWrapper.css - component css
|
||
|
|
* @param {Function} componentWrapper.template - function that will return the dom-bindings template function
|
||
|
|
* @param {Object} componentWrapper.exports - component interface
|
||
|
|
* @param {string} componentWrapper.name - component name
|
||
|
|
* @returns {Object} component like interface
|
||
|
|
*/
|
||
|
|
function createComponentFromWrapper(componentWrapper) {
|
||
|
|
const {
|
||
|
|
css,
|
||
|
|
template,
|
||
|
|
exports,
|
||
|
|
name
|
||
|
|
} = componentWrapper;
|
||
|
|
const templateFn = template ? (0,_component_template_factory_js__WEBPACK_IMPORTED_MODULE_4__.componentTemplateFactory)(template, componentWrapper, createChildComponentGetter(componentWrapper)) : _mocked_template_interface_js__WEBPACK_IMPORTED_MODULE_5__.MOCKED_TEMPLATE_INTERFACE;
|
||
|
|
return _ref2 => {
|
||
|
|
let {
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
props
|
||
|
|
} = _ref2;
|
||
|
|
// pure components rendering will be managed by the end user
|
||
|
|
if (exports && exports[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_2__.IS_PURE_SYMBOL]) return (0,_create_pure_component_js__WEBPACK_IMPORTED_MODULE_6__.createPureComponent)(exports, {
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
props,
|
||
|
|
css,
|
||
|
|
template
|
||
|
|
});
|
||
|
|
const componentAPI = (0,_node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__.callOrAssign)(exports) || {};
|
||
|
|
const component = (0,_instantiate_component_js__WEBPACK_IMPORTED_MODULE_7__.instantiateComponent)({
|
||
|
|
css,
|
||
|
|
template: templateFn,
|
||
|
|
componentAPI,
|
||
|
|
name
|
||
|
|
})({
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
props
|
||
|
|
});
|
||
|
|
|
||
|
|
// notice that for the components created via tag binding
|
||
|
|
// we need to invert the mount (state/parentScope) arguments
|
||
|
|
// the template bindings will only forward the parentScope updates
|
||
|
|
// and never deal with the component state
|
||
|
|
return {
|
||
|
|
mount(element, parentScope, state) {
|
||
|
|
return component.mount(element, state, parentScope);
|
||
|
|
},
|
||
|
|
update(parentScope, state) {
|
||
|
|
return component.update(state, parentScope);
|
||
|
|
},
|
||
|
|
unmount(preserveRoot) {
|
||
|
|
return component.unmount(preserveRoot);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/create-core-api-methods.js":
|
||
|
|
/*!***************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/create-core-api-methods.js ***!
|
||
|
|
\***************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "createCoreAPIMethods": () => (/* binding */ createCoreAPIMethods)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Wrap the Riot.js core API methods using a mapping function
|
||
|
|
* @param {Function} mapFunction - lifting function
|
||
|
|
* @returns {Object} an object having the { mount, update, unmount } functions
|
||
|
|
*/
|
||
|
|
function createCoreAPIMethods(mapFunction) {
|
||
|
|
return [_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.MOUNT_METHOD_KEY, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.UPDATE_METHOD_KEY, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.UNMOUNT_METHOD_KEY].reduce((acc, method) => {
|
||
|
|
acc[method] = mapFunction(method);
|
||
|
|
return acc;
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/create-pure-component.js":
|
||
|
|
/*!*************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/create-pure-component.js ***!
|
||
|
|
\*************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "createPureComponent": () => (/* binding */ createPureComponent)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/objects.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/objects.js");
|
||
|
|
/* harmony import */ var _pure_component_api_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./pure-component-api.js */ "./node_modules/riot/esm/core/pure-component-api.js");
|
||
|
|
/* harmony import */ var _bind_dom_node_to_component_instance_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./bind-dom-node-to-component-instance.js */ "./node_modules/riot/esm/core/bind-dom-node-to-component-instance.js");
|
||
|
|
/* harmony import */ var _create_core_api_methods_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./create-core-api-methods.js */ "./node_modules/riot/esm/core/create-core-api-methods.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a pure component
|
||
|
|
* @param {Function} pureFactoryFunction - pure component factory function
|
||
|
|
* @param {Array} options.slots - component slots
|
||
|
|
* @param {Array} options.attributes - component attributes
|
||
|
|
* @param {Array} options.template - template factory function
|
||
|
|
* @param {Array} options.template - template factory function
|
||
|
|
* @param {any} options.props - initial component properties
|
||
|
|
* @returns {Object} pure component object
|
||
|
|
*/
|
||
|
|
function createPureComponent(pureFactoryFunction, _ref) {
|
||
|
|
let {
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
props,
|
||
|
|
css,
|
||
|
|
template
|
||
|
|
} = _ref;
|
||
|
|
if (template) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_0__.panic)('Pure components can not have html');
|
||
|
|
if (css) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_0__.panic)('Pure components do not have css');
|
||
|
|
const component = (0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_1__.defineDefaults)(pureFactoryFunction({
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
props
|
||
|
|
}), _pure_component_api_js__WEBPACK_IMPORTED_MODULE_2__.PURE_COMPONENT_API);
|
||
|
|
return (0,_create_core_api_methods_js__WEBPACK_IMPORTED_MODULE_3__.createCoreAPIMethods)(method => function () {
|
||
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
|
|
args[_key] = arguments[_key];
|
||
|
|
}
|
||
|
|
// intercept the mount calls to bind the DOM node to the pure object created
|
||
|
|
// see also https://github.com/riot/riot/issues/2806
|
||
|
|
if (method === _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.MOUNT_METHOD_KEY) {
|
||
|
|
const [element] = args;
|
||
|
|
// mark this node as pure element
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_1__.defineProperty)(element, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.IS_PURE_SYMBOL, true);
|
||
|
|
(0,_bind_dom_node_to_component_instance_js__WEBPACK_IMPORTED_MODULE_5__.bindDOMNodeToComponentInstance)(element, component);
|
||
|
|
}
|
||
|
|
component[method](...args);
|
||
|
|
return component;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/css-manager.js":
|
||
|
|
/*!***************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/css-manager.js ***!
|
||
|
|
\***************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "CSS_BY_NAME": () => (/* binding */ CSS_BY_NAME),
|
||
|
|
/* harmony export */ "STYLE_NODE_SELECTOR": () => (/* binding */ STYLE_NODE_SELECTOR),
|
||
|
|
/* harmony export */ "default": () => (/* binding */ cssManager)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/bianco.query/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.query/index.next.js");
|
||
|
|
/* harmony import */ var _node_modules_bianco_attr_index_next_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/bianco.attr/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.attr/index.next.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
const CSS_BY_NAME = new Map();
|
||
|
|
const STYLE_NODE_SELECTOR = 'style[riot]';
|
||
|
|
|
||
|
|
// memoized curried function
|
||
|
|
const getStyleNode = (style => {
|
||
|
|
return () => {
|
||
|
|
// lazy evaluation:
|
||
|
|
// if this function was already called before
|
||
|
|
// we return its cached result
|
||
|
|
if (style) return style;
|
||
|
|
|
||
|
|
// create a new style element or use an existing one
|
||
|
|
// and cache it internally
|
||
|
|
style = (0,_node_modules_bianco_query_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(STYLE_NODE_SELECTOR)[0] || document.createElement('style');
|
||
|
|
(0,_node_modules_bianco_attr_index_next_js__WEBPACK_IMPORTED_MODULE_1__.set)(style, 'type', 'text/css');
|
||
|
|
|
||
|
|
/* istanbul ignore next */
|
||
|
|
if (!style.parentNode) document.head.appendChild(style);
|
||
|
|
return style;
|
||
|
|
};
|
||
|
|
})();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Object that will be used to inject and manage the css of every tag instance
|
||
|
|
*/
|
||
|
|
const cssManager = {
|
||
|
|
CSS_BY_NAME,
|
||
|
|
/**
|
||
|
|
* Save a tag style to be later injected into DOM
|
||
|
|
* @param { string } name - if it's passed we will map the css to a tagname
|
||
|
|
* @param { string } css - css string
|
||
|
|
* @returns {Object} self
|
||
|
|
*/
|
||
|
|
add(name, css) {
|
||
|
|
if (!CSS_BY_NAME.has(name)) {
|
||
|
|
CSS_BY_NAME.set(name, css);
|
||
|
|
this.inject();
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Inject all previously saved tag styles into DOM
|
||
|
|
* innerHTML seems slow: http://jsperf.com/riot-insert-style
|
||
|
|
* @returns {Object} self
|
||
|
|
*/
|
||
|
|
inject() {
|
||
|
|
getStyleNode().innerHTML = [...CSS_BY_NAME.values()].join('\n');
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Remove a tag style from the DOM
|
||
|
|
* @param {string} name a registered tagname
|
||
|
|
* @returns {Object} self
|
||
|
|
*/
|
||
|
|
remove(name) {
|
||
|
|
if (CSS_BY_NAME.has(name)) {
|
||
|
|
CSS_BY_NAME.delete(name);
|
||
|
|
this.inject();
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/instantiate-component.js":
|
||
|
|
/*!*************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/instantiate-component.js ***!
|
||
|
|
\*************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "instantiateComponent": () => (/* binding */ instantiateComponent)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../node_modules/@riotjs/util/objects.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/objects.js");
|
||
|
|
/* harmony import */ var _component_dom_selectors_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./component-dom-selectors.js */ "./node_modules/riot/esm/core/component-dom-selectors.js");
|
||
|
|
/* harmony import */ var _component_lifecycle_methods_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./component-lifecycle-methods.js */ "./node_modules/riot/esm/core/component-lifecycle-methods.js");
|
||
|
|
/* harmony import */ var _css_manager_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./css-manager.js */ "./node_modules/riot/esm/core/css-manager.js");
|
||
|
|
/* harmony import */ var _node_modules_curri_index_next_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/curri/index.next.js */ "./node_modules/riot/esm/node_modules/curri/index.next.js");
|
||
|
|
/* harmony import */ var _manage_component_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./manage-component-lifecycle.js */ "./node_modules/riot/esm/core/manage-component-lifecycle.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Component definition function
|
||
|
|
* @param {Object} implementation - the component implementation will be generated via compiler
|
||
|
|
* @param {Object} component - the component initial properties
|
||
|
|
* @returns {Object} a new component implementation object
|
||
|
|
*/
|
||
|
|
function instantiateComponent(_ref) {
|
||
|
|
let {
|
||
|
|
css,
|
||
|
|
template,
|
||
|
|
componentAPI,
|
||
|
|
name
|
||
|
|
} = _ref;
|
||
|
|
// add the component css into the DOM
|
||
|
|
if (css && name) _css_manager_js__WEBPACK_IMPORTED_MODULE_0__["default"].add(name, css);
|
||
|
|
return (0,_node_modules_curri_index_next_js__WEBPACK_IMPORTED_MODULE_1__["default"])(_manage_component_lifecycle_js__WEBPACK_IMPORTED_MODULE_2__.manageComponentLifecycle)((0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_3__.defineProperties)(
|
||
|
|
// set the component defaults without overriding the original component API
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_3__.defineDefaults)(componentAPI, Object.assign({}, _component_lifecycle_methods_js__WEBPACK_IMPORTED_MODULE_4__.COMPONENT_LIFECYCLE_METHODS, {
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_5__.PROPS_KEY]: {},
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_5__.STATE_KEY]: {}
|
||
|
|
})), Object.assign({
|
||
|
|
// defined during the component creation
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_5__.SLOTS_KEY]: null,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_5__.ROOT_KEY]: null
|
||
|
|
}, _component_dom_selectors_js__WEBPACK_IMPORTED_MODULE_6__.COMPONENT_DOM_SELECTORS, {
|
||
|
|
name,
|
||
|
|
css,
|
||
|
|
template
|
||
|
|
})));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/manage-component-lifecycle.js":
|
||
|
|
/*!******************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/manage-component-lifecycle.js ***!
|
||
|
|
\******************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "manageComponentLifecycle": () => (/* binding */ manageComponentLifecycle)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../node_modules/@riotjs/util/checks.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/checks.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/objects.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/objects.js");
|
||
|
|
/* harmony import */ var _add_css_hook_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./add-css-hook.js */ "./node_modules/riot/esm/core/add-css-hook.js");
|
||
|
|
/* harmony import */ var _bind_dom_node_to_component_instance_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./bind-dom-node-to-component-instance.js */ "./node_modules/riot/esm/core/bind-dom-node-to-component-instance.js");
|
||
|
|
/* harmony import */ var _compute_component_state_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./compute-component-state.js */ "./node_modules/riot/esm/core/compute-component-state.js");
|
||
|
|
/* harmony import */ var _compute_initial_props_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./compute-initial-props.js */ "./node_modules/riot/esm/core/compute-initial-props.js");
|
||
|
|
/* harmony import */ var _create_attribute_bindings_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./create-attribute-bindings.js */ "./node_modules/riot/esm/core/create-attribute-bindings.js");
|
||
|
|
/* harmony import */ var _run_plugins_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./run-plugins.js */ "./node_modules/riot/esm/core/run-plugins.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Component creation factory function that will enhance the user provided API
|
||
|
|
* @param {Object} component - a component implementation previously defined
|
||
|
|
* @param {Array} options.slots - component slots generated via riot compiler
|
||
|
|
* @param {Array} options.attributes - attribute expressions generated via riot compiler
|
||
|
|
* @returns {Riot.Component} a riot component instance
|
||
|
|
*/
|
||
|
|
function manageComponentLifecycle(component, _ref) {
|
||
|
|
let {
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
props
|
||
|
|
} = _ref;
|
||
|
|
return (0,_node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_0__.autobindMethods)((0,_run_plugins_js__WEBPACK_IMPORTED_MODULE_1__.runPlugins)((0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__.defineProperties)((0,_node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_3__.isObject)(component) ? Object.create(component) : component, {
|
||
|
|
mount(element, state, parentScope) {
|
||
|
|
if (state === void 0) {
|
||
|
|
state = {};
|
||
|
|
}
|
||
|
|
// any element mounted passing through this function can't be a pure component
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__.defineProperty)(element, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.IS_PURE_SYMBOL, false);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PARENT_KEY_SYMBOL] = parentScope;
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ATTRIBUTES_KEY_SYMBOL] = (0,_create_attribute_bindings_js__WEBPACK_IMPORTED_MODULE_5__.createAttributeBindings)(element, attributes).mount(parentScope);
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__.defineProperty)(this, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY, Object.freeze(Object.assign({}, (0,_compute_initial_props_js__WEBPACK_IMPORTED_MODULE_6__.computeInitialProps)(element, props), (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_7__.evaluateAttributeExpressions)(this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ATTRIBUTES_KEY_SYMBOL].expressions))));
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY] = (0,_compute_component_state_js__WEBPACK_IMPORTED_MODULE_8__.computeComponentState)(this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY], state);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.TEMPLATE_KEY_SYMBOL] = this.template.createDOM(element).clone();
|
||
|
|
|
||
|
|
// link this object to the DOM node
|
||
|
|
(0,_bind_dom_node_to_component_instance_js__WEBPACK_IMPORTED_MODULE_9__.bindDOMNodeToComponentInstance)(element, this);
|
||
|
|
// add eventually the 'is' attribute
|
||
|
|
component.name && (0,_add_css_hook_js__WEBPACK_IMPORTED_MODULE_10__.addCssHook)(element, component.name);
|
||
|
|
|
||
|
|
// define the root element
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__.defineProperty)(this, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ROOT_KEY, element);
|
||
|
|
// define the slots array
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__.defineProperty)(this, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.SLOTS_KEY, slots);
|
||
|
|
|
||
|
|
// before mount lifecycle event
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ON_BEFORE_MOUNT_KEY](this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY]);
|
||
|
|
// mount the template
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.TEMPLATE_KEY_SYMBOL].mount(element, this, parentScope);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ON_MOUNTED_KEY](this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY]);
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
update(state, parentScope) {
|
||
|
|
if (state === void 0) {
|
||
|
|
state = {};
|
||
|
|
}
|
||
|
|
if (parentScope) {
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PARENT_KEY_SYMBOL] = parentScope;
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ATTRIBUTES_KEY_SYMBOL].update(parentScope);
|
||
|
|
}
|
||
|
|
const newProps = (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_7__.evaluateAttributeExpressions)(this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ATTRIBUTES_KEY_SYMBOL].expressions);
|
||
|
|
if (this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.SHOULD_UPDATE_KEY](newProps, this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY]) === false) return;
|
||
|
|
(0,_node_modules_riotjs_util_objects_js__WEBPACK_IMPORTED_MODULE_2__.defineProperty)(this, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY, Object.freeze(Object.assign({}, this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], newProps)));
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY] = (0,_compute_component_state_js__WEBPACK_IMPORTED_MODULE_8__.computeComponentState)(this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY], state);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ON_BEFORE_UPDATE_KEY](this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY]);
|
||
|
|
|
||
|
|
// avoiding recursive updates
|
||
|
|
// see also https://github.com/riot/riot/issues/2895
|
||
|
|
if (!this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.IS_COMPONENT_UPDATING]) {
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.IS_COMPONENT_UPDATING] = true;
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.TEMPLATE_KEY_SYMBOL].update(this, this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PARENT_KEY_SYMBOL]);
|
||
|
|
}
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ON_UPDATED_KEY](this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY]);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.IS_COMPONENT_UPDATING] = false;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
unmount(preserveRoot) {
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ON_BEFORE_UNMOUNT_KEY](this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY]);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ATTRIBUTES_KEY_SYMBOL].unmount();
|
||
|
|
// if the preserveRoot is null the template html will be left untouched
|
||
|
|
// in that case the DOM cleanup will happen differently from a parent node
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.TEMPLATE_KEY_SYMBOL].unmount(this, this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PARENT_KEY_SYMBOL], preserveRoot === null ? null : !preserveRoot);
|
||
|
|
this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.ON_UNMOUNTED_KEY](this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.PROPS_KEY], this[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_4__.STATE_KEY]);
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
})), Object.keys(component).filter(prop => (0,_node_modules_riotjs_util_checks_js__WEBPACK_IMPORTED_MODULE_3__.isFunction)(component[prop])));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/mocked-template-interface.js":
|
||
|
|
/*!*****************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/mocked-template-interface.js ***!
|
||
|
|
\*****************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "MOCKED_TEMPLATE_INTERFACE": () => (/* binding */ MOCKED_TEMPLATE_INTERFACE)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _pure_component_api_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./pure-component-api.js */ "./node_modules/riot/esm/core/pure-component-api.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
const MOCKED_TEMPLATE_INTERFACE = Object.assign({}, _pure_component_api_js__WEBPACK_IMPORTED_MODULE_0__.PURE_COMPONENT_API, {
|
||
|
|
clone: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
createDOM: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/mount-component.js":
|
||
|
|
/*!*******************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/mount-component.js ***!
|
||
|
|
\*******************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "mountComponent": () => (/* binding */ mountComponent)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../node_modules/@riotjs/util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* harmony import */ var _utils_dom_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/dom.js */ "./node_modules/riot/esm/utils/dom.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Component initialization function starting from a DOM node
|
||
|
|
* @param {HTMLElement} element - element to upgrade
|
||
|
|
* @param {Object} initialProps - initial component properties
|
||
|
|
* @param {string} componentName - component id
|
||
|
|
* @param {Array} slots - component slots
|
||
|
|
* @returns {Object} a new component instance bound to a DOM node
|
||
|
|
*/
|
||
|
|
function mountComponent(element, initialProps, componentName, slots) {
|
||
|
|
const name = componentName || (0,_utils_dom_js__WEBPACK_IMPORTED_MODULE_0__.getName)(element);
|
||
|
|
if (!_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__.COMPONENTS_IMPLEMENTATION_MAP.has(name)) (0,_node_modules_riotjs_util_misc_js__WEBPACK_IMPORTED_MODULE_2__.panic)(`The component named "${name}" was never registered`);
|
||
|
|
const component = _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__.COMPONENTS_IMPLEMENTATION_MAP.get(name)({
|
||
|
|
props: initialProps,
|
||
|
|
slots
|
||
|
|
});
|
||
|
|
return component.mount(element);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/pure-component-api.js":
|
||
|
|
/*!**********************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/pure-component-api.js ***!
|
||
|
|
\**********************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "PURE_COMPONENT_API": () => (/* binding */ PURE_COMPONENT_API)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/functions.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
const PURE_COMPONENT_API = Object.freeze({
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.MOUNT_METHOD_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.UPDATE_METHOD_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop,
|
||
|
|
[_node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.UNMOUNT_METHOD_KEY]: _node_modules_riotjs_util_functions_js__WEBPACK_IMPORTED_MODULE_1__.noop
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/core/run-plugins.js":
|
||
|
|
/*!***************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/core/run-plugins.js ***!
|
||
|
|
\***************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "runPlugins": () => (/* binding */ runPlugins)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Run the component instance through all the plugins set by the user
|
||
|
|
* @param {Object} component - component instance
|
||
|
|
* @returns {Object} the component enhanced by the plugins
|
||
|
|
*/
|
||
|
|
function runPlugins(component) {
|
||
|
|
return [..._node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_0__.PLUGINS_SET].reduce((c, fn) => fn(c) || c, component);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js":
|
||
|
|
/*!******************************************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/dom-bindings/dist/esm.dom-bindings.js ***!
|
||
|
|
\******************************************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "bindingTypes": () => (/* reexport safe */ _util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__["default"]),
|
||
|
|
/* harmony export */ "createBinding": () => (/* binding */ create$1),
|
||
|
|
/* harmony export */ "createExpression": () => (/* binding */ create$4),
|
||
|
|
/* harmony export */ "expressionTypes": () => (/* reexport safe */ _util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__["default"]),
|
||
|
|
/* harmony export */ "template": () => (/* binding */ create)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _util_dom_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../util/dom.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/dom.js");
|
||
|
|
/* harmony import */ var _util_constants_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../util/binding-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/binding-types.js");
|
||
|
|
/* harmony import */ var _util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../util/expression-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/expression-types.js");
|
||
|
|
/* harmony import */ var _util_objects_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../util/objects.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/objects.js");
|
||
|
|
/* harmony import */ var _util_checks_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../util/checks.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/checks.js");
|
||
|
|
/* harmony import */ var _util_misc_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../util/misc.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js");
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
const HEAD_SYMBOL = Symbol();
|
||
|
|
const TAIL_SYMBOL = Symbol();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the <template> fragments text nodes
|
||
|
|
* @return {Object} {{head: Text, tail: Text}}
|
||
|
|
*/
|
||
|
|
function createHeadTailPlaceholders() {
|
||
|
|
const head = document.createTextNode('');
|
||
|
|
const tail = document.createTextNode('');
|
||
|
|
head[HEAD_SYMBOL] = true;
|
||
|
|
tail[TAIL_SYMBOL] = true;
|
||
|
|
return {
|
||
|
|
head,
|
||
|
|
tail
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the template meta object in case of <template> fragments
|
||
|
|
* @param {TemplateChunk} componentTemplate - template chunk object
|
||
|
|
* @returns {Object} the meta property that will be passed to the mount function of the TemplateChunk
|
||
|
|
*/
|
||
|
|
function createTemplateMeta(componentTemplate) {
|
||
|
|
const fragment = componentTemplate.dom.cloneNode(true);
|
||
|
|
const {
|
||
|
|
head,
|
||
|
|
tail
|
||
|
|
} = createHeadTailPlaceholders();
|
||
|
|
return {
|
||
|
|
avoidDOMInjection: true,
|
||
|
|
fragment,
|
||
|
|
head,
|
||
|
|
tail,
|
||
|
|
children: [head, ...Array.from(fragment.childNodes), tail]
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* ISC License
|
||
|
|
*
|
||
|
|
* Copyright (c) 2020, Andrea Giammarchi, @WebReflection
|
||
|
|
*
|
||
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
||
|
|
* purpose with or without fee is hereby granted, provided that the above
|
||
|
|
* copyright notice and this permission notice appear in all copies.
|
||
|
|
*
|
||
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||
|
|
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||
|
|
* AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||
|
|
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||
|
|
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
||
|
|
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
||
|
|
*/
|
||
|
|
|
||
|
|
// fork of https://github.com/WebReflection/udomdiff version 1.1.0
|
||
|
|
// due to https://github.com/WebReflection/udomdiff/pull/2
|
||
|
|
/* eslint-disable */
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param {Node[]} a The list of current/live children
|
||
|
|
* @param {Node[]} b The list of future children
|
||
|
|
* @param {(entry: Node, action: number) => Node} get
|
||
|
|
* The callback invoked per each entry related DOM operation.
|
||
|
|
* @param {Node} [before] The optional node used as anchor to insert before.
|
||
|
|
* @returns {Node[]} The same list of future children.
|
||
|
|
*/
|
||
|
|
const udomdiff = (a, b, get, before) => {
|
||
|
|
const bLength = b.length;
|
||
|
|
let aEnd = a.length;
|
||
|
|
let bEnd = bLength;
|
||
|
|
let aStart = 0;
|
||
|
|
let bStart = 0;
|
||
|
|
let map = null;
|
||
|
|
while (aStart < aEnd || bStart < bEnd) {
|
||
|
|
// append head, tail, or nodes in between: fast path
|
||
|
|
if (aEnd === aStart) {
|
||
|
|
// we could be in a situation where the rest of nodes that
|
||
|
|
// need to be added are not at the end, and in such case
|
||
|
|
// the node to `insertBefore`, if the index is more than 0
|
||
|
|
// must be retrieved, otherwise it's gonna be the first item.
|
||
|
|
const node = bEnd < bLength ? bStart ? get(b[bStart - 1], -0).nextSibling : get(b[bEnd - bStart], 0) : before;
|
||
|
|
while (bStart < bEnd) (0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(get(b[bStart++], 1), node);
|
||
|
|
}
|
||
|
|
// remove head or tail: fast path
|
||
|
|
else if (bEnd === bStart) {
|
||
|
|
while (aStart < aEnd) {
|
||
|
|
// remove the node only if it's unknown or not live
|
||
|
|
if (!map || !map.has(a[aStart])) (0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.removeChild)(get(a[aStart], -1));
|
||
|
|
aStart++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// same node: fast path
|
||
|
|
else if (a[aStart] === b[bStart]) {
|
||
|
|
aStart++;
|
||
|
|
bStart++;
|
||
|
|
}
|
||
|
|
// same tail: fast path
|
||
|
|
else if (a[aEnd - 1] === b[bEnd - 1]) {
|
||
|
|
aEnd--;
|
||
|
|
bEnd--;
|
||
|
|
}
|
||
|
|
// The once here single last swap "fast path" has been removed in v1.1.0
|
||
|
|
// https://github.com/WebReflection/udomdiff/blob/single-final-swap/esm/index.js#L69-L85
|
||
|
|
// reverse swap: also fast path
|
||
|
|
else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
|
||
|
|
// this is a "shrink" operation that could happen in these cases:
|
||
|
|
// [1, 2, 3, 4, 5]
|
||
|
|
// [1, 4, 3, 2, 5]
|
||
|
|
// or asymmetric too
|
||
|
|
// [1, 2, 3, 4, 5]
|
||
|
|
// [1, 2, 3, 5, 6, 4]
|
||
|
|
const node = get(a[--aEnd], -1).nextSibling;
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(get(b[bStart++], 1), get(a[aStart++], -1).nextSibling);
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(get(b[--bEnd], 1), node);
|
||
|
|
// mark the future index as identical (yeah, it's dirty, but cheap 👍)
|
||
|
|
// The main reason to do this, is that when a[aEnd] will be reached,
|
||
|
|
// the loop will likely be on the fast path, as identical to b[bEnd].
|
||
|
|
// In the best case scenario, the next loop will skip the tail,
|
||
|
|
// but in the worst one, this node will be considered as already
|
||
|
|
// processed, bailing out pretty quickly from the map index check
|
||
|
|
a[aEnd] = b[bEnd];
|
||
|
|
}
|
||
|
|
// map based fallback, "slow" path
|
||
|
|
else {
|
||
|
|
// the map requires an O(bEnd - bStart) operation once
|
||
|
|
// to store all future nodes indexes for later purposes.
|
||
|
|
// In the worst case scenario, this is a full O(N) cost,
|
||
|
|
// and such scenario happens at least when all nodes are different,
|
||
|
|
// but also if both first and last items of the lists are different
|
||
|
|
if (!map) {
|
||
|
|
map = new Map();
|
||
|
|
let i = bStart;
|
||
|
|
while (i < bEnd) map.set(b[i], i++);
|
||
|
|
}
|
||
|
|
// if it's a future node, hence it needs some handling
|
||
|
|
if (map.has(a[aStart])) {
|
||
|
|
// grab the index of such node, 'cause it might have been processed
|
||
|
|
const index = map.get(a[aStart]);
|
||
|
|
// if it's not already processed, look on demand for the next LCS
|
||
|
|
if (bStart < index && index < bEnd) {
|
||
|
|
let i = aStart;
|
||
|
|
// counts the amount of nodes that are the same in the future
|
||
|
|
let sequence = 1;
|
||
|
|
while (++i < aEnd && i < bEnd && map.get(a[i]) === index + sequence) sequence++;
|
||
|
|
// effort decision here: if the sequence is longer than replaces
|
||
|
|
// needed to reach such sequence, which would brings again this loop
|
||
|
|
// to the fast path, prepend the difference before a sequence,
|
||
|
|
// and move only the future list index forward, so that aStart
|
||
|
|
// and bStart will be aligned again, hence on the fast path.
|
||
|
|
// An example considering aStart and bStart are both 0:
|
||
|
|
// a: [1, 2, 3, 4]
|
||
|
|
// b: [7, 1, 2, 3, 6]
|
||
|
|
// this would place 7 before 1 and, from that time on, 1, 2, and 3
|
||
|
|
// will be processed at zero cost
|
||
|
|
if (sequence > index - bStart) {
|
||
|
|
const node = get(a[aStart], 0);
|
||
|
|
while (bStart < index) (0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(get(b[bStart++], 1), node);
|
||
|
|
}
|
||
|
|
// if the effort wasn't good enough, fallback to a replace,
|
||
|
|
// moving both source and target indexes forward, hoping that some
|
||
|
|
// similar node will be found later on, to go back to the fast path
|
||
|
|
else {
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.replaceChild)(get(b[bStart++], 1), get(a[aStart++], -1));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// otherwise move the source forward, 'cause there's nothing to do
|
||
|
|
else aStart++;
|
||
|
|
}
|
||
|
|
// this node has no meaning in the future list, so it's more than safe
|
||
|
|
// to remove it, and check the next live node out instead, meaning
|
||
|
|
// that only the live list index should be forwarded
|
||
|
|
else (0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.removeChild)(get(a[aStart++], -1));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return b;
|
||
|
|
};
|
||
|
|
const UNMOUNT_SCOPE = Symbol('unmount');
|
||
|
|
const EachBinding = {
|
||
|
|
// dynamic binding properties
|
||
|
|
// childrenMap: null,
|
||
|
|
// node: null,
|
||
|
|
// root: null,
|
||
|
|
// condition: null,
|
||
|
|
// evaluate: null,
|
||
|
|
// template: null,
|
||
|
|
// isTemplateTag: false,
|
||
|
|
nodes: [],
|
||
|
|
// getKey: null,
|
||
|
|
// indexName: null,
|
||
|
|
// itemName: null,
|
||
|
|
// afterPlaceholder: null,
|
||
|
|
// placeholder: null,
|
||
|
|
|
||
|
|
// API methods
|
||
|
|
mount(scope, parentScope) {
|
||
|
|
return this.update(scope, parentScope);
|
||
|
|
},
|
||
|
|
update(scope, parentScope) {
|
||
|
|
const {
|
||
|
|
placeholder,
|
||
|
|
nodes,
|
||
|
|
childrenMap
|
||
|
|
} = this;
|
||
|
|
const collection = scope === UNMOUNT_SCOPE ? null : this.evaluate(scope);
|
||
|
|
const items = collection ? Array.from(collection) : [];
|
||
|
|
|
||
|
|
// prepare the diffing
|
||
|
|
const {
|
||
|
|
newChildrenMap,
|
||
|
|
batches,
|
||
|
|
futureNodes
|
||
|
|
} = createPatch(items, scope, parentScope, this);
|
||
|
|
|
||
|
|
// patch the DOM only if there are new nodes
|
||
|
|
udomdiff(nodes, futureNodes, patch(Array.from(childrenMap.values()), parentScope), placeholder);
|
||
|
|
|
||
|
|
// trigger the mounts and the updates
|
||
|
|
batches.forEach(fn => fn());
|
||
|
|
|
||
|
|
// update the children map
|
||
|
|
this.childrenMap = newChildrenMap;
|
||
|
|
this.nodes = futureNodes;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
unmount(scope, parentScope) {
|
||
|
|
this.update(UNMOUNT_SCOPE, parentScope);
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Patch the DOM while diffing
|
||
|
|
* @param {any[]} redundant - list of all the children (template, nodes, context) added via each
|
||
|
|
* @param {*} parentScope - scope of the parent template
|
||
|
|
* @returns {Function} patch function used by domdiff
|
||
|
|
*/
|
||
|
|
function patch(redundant, parentScope) {
|
||
|
|
return (item, info) => {
|
||
|
|
if (info < 0) {
|
||
|
|
// get the last element added to the childrenMap saved previously
|
||
|
|
const element = redundant[redundant.length - 1];
|
||
|
|
if (element) {
|
||
|
|
// get the nodes and the template in stored in the last child of the childrenMap
|
||
|
|
const {
|
||
|
|
template,
|
||
|
|
nodes,
|
||
|
|
context
|
||
|
|
} = element;
|
||
|
|
// remove the last node (notice <template> tags might have more children nodes)
|
||
|
|
nodes.pop();
|
||
|
|
|
||
|
|
// notice that we pass null as last argument because
|
||
|
|
// the root node and its children will be removed by domdiff
|
||
|
|
if (!nodes.length) {
|
||
|
|
// we have cleared all the children nodes and we can unmount this template
|
||
|
|
redundant.pop();
|
||
|
|
template.unmount(context, parentScope, null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return item;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check whether a template must be filtered from a loop
|
||
|
|
* @param {Function} condition - filter function
|
||
|
|
* @param {Object} context - argument passed to the filter function
|
||
|
|
* @returns {boolean} true if this item should be skipped
|
||
|
|
*/
|
||
|
|
function mustFilterItem(condition, context) {
|
||
|
|
return condition ? !condition(context) : false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Extend the scope of the looped template
|
||
|
|
* @param {Object} scope - current template scope
|
||
|
|
* @param {Object} options - options
|
||
|
|
* @param {string} options.itemName - key to identify the looped item in the new context
|
||
|
|
* @param {string} options.indexName - key to identify the index of the looped item
|
||
|
|
* @param {number} options.index - current index
|
||
|
|
* @param {*} options.item - collection item looped
|
||
|
|
* @returns {Object} enhanced scope object
|
||
|
|
*/
|
||
|
|
function extendScope(scope, _ref) {
|
||
|
|
let {
|
||
|
|
itemName,
|
||
|
|
indexName,
|
||
|
|
index,
|
||
|
|
item
|
||
|
|
} = _ref;
|
||
|
|
(0,_util_objects_js__WEBPACK_IMPORTED_MODULE_3__.defineProperty)(scope, itemName, item);
|
||
|
|
if (indexName) (0,_util_objects_js__WEBPACK_IMPORTED_MODULE_3__.defineProperty)(scope, indexName, index);
|
||
|
|
return scope;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Loop the current template items
|
||
|
|
* @param {Array} items - expression collection value
|
||
|
|
* @param {*} scope - template scope
|
||
|
|
* @param {*} parentScope - scope of the parent template
|
||
|
|
* @param {EachBinding} binding - each binding object instance
|
||
|
|
* @returns {Object} data
|
||
|
|
* @returns {Map} data.newChildrenMap - a Map containing the new children template structure
|
||
|
|
* @returns {Array} data.batches - array containing the template lifecycle functions to trigger
|
||
|
|
* @returns {Array} data.futureNodes - array containing the nodes we need to diff
|
||
|
|
*/
|
||
|
|
function createPatch(items, scope, parentScope, binding) {
|
||
|
|
const {
|
||
|
|
condition,
|
||
|
|
template,
|
||
|
|
childrenMap,
|
||
|
|
itemName,
|
||
|
|
getKey,
|
||
|
|
indexName,
|
||
|
|
root,
|
||
|
|
isTemplateTag
|
||
|
|
} = binding;
|
||
|
|
const newChildrenMap = new Map();
|
||
|
|
const batches = [];
|
||
|
|
const futureNodes = [];
|
||
|
|
items.forEach((item, index) => {
|
||
|
|
const context = extendScope(Object.create(scope), {
|
||
|
|
itemName,
|
||
|
|
indexName,
|
||
|
|
index,
|
||
|
|
item
|
||
|
|
});
|
||
|
|
const key = getKey ? getKey(context) : index;
|
||
|
|
const oldItem = childrenMap.get(key);
|
||
|
|
const nodes = [];
|
||
|
|
if (mustFilterItem(condition, context)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const mustMount = !oldItem;
|
||
|
|
const componentTemplate = oldItem ? oldItem.template : template.clone();
|
||
|
|
const el = componentTemplate.el || root.cloneNode();
|
||
|
|
const meta = isTemplateTag && mustMount ? createTemplateMeta(componentTemplate) : componentTemplate.meta;
|
||
|
|
if (mustMount) {
|
||
|
|
batches.push(() => componentTemplate.mount(el, context, parentScope, meta));
|
||
|
|
} else {
|
||
|
|
batches.push(() => componentTemplate.update(context, parentScope));
|
||
|
|
}
|
||
|
|
|
||
|
|
// create the collection of nodes to update or to add
|
||
|
|
// in case of template tags we need to add all its children nodes
|
||
|
|
if (isTemplateTag) {
|
||
|
|
nodes.push(...meta.children);
|
||
|
|
} else {
|
||
|
|
nodes.push(el);
|
||
|
|
}
|
||
|
|
|
||
|
|
// delete the old item from the children map
|
||
|
|
childrenMap.delete(key);
|
||
|
|
futureNodes.push(...nodes);
|
||
|
|
|
||
|
|
// update the children map
|
||
|
|
newChildrenMap.set(key, {
|
||
|
|
nodes,
|
||
|
|
template: componentTemplate,
|
||
|
|
context,
|
||
|
|
index
|
||
|
|
});
|
||
|
|
});
|
||
|
|
return {
|
||
|
|
newChildrenMap,
|
||
|
|
batches,
|
||
|
|
futureNodes
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function create$6(node, _ref2) {
|
||
|
|
let {
|
||
|
|
evaluate,
|
||
|
|
condition,
|
||
|
|
itemName,
|
||
|
|
indexName,
|
||
|
|
getKey,
|
||
|
|
template
|
||
|
|
} = _ref2;
|
||
|
|
const placeholder = document.createTextNode('');
|
||
|
|
const root = node.cloneNode();
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(placeholder, node);
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.removeChild)(node);
|
||
|
|
return Object.assign({}, EachBinding, {
|
||
|
|
childrenMap: new Map(),
|
||
|
|
node,
|
||
|
|
root,
|
||
|
|
condition,
|
||
|
|
evaluate,
|
||
|
|
isTemplateTag: (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isTemplate)(root),
|
||
|
|
template: template.createDOM(node),
|
||
|
|
getKey,
|
||
|
|
indexName,
|
||
|
|
itemName,
|
||
|
|
placeholder
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Binding responsible for the `if` directive
|
||
|
|
*/
|
||
|
|
const IfBinding = {
|
||
|
|
// dynamic binding properties
|
||
|
|
// node: null,
|
||
|
|
// evaluate: null,
|
||
|
|
// isTemplateTag: false,
|
||
|
|
// placeholder: null,
|
||
|
|
// template: null,
|
||
|
|
|
||
|
|
// API methods
|
||
|
|
mount(scope, parentScope) {
|
||
|
|
return this.update(scope, parentScope);
|
||
|
|
},
|
||
|
|
update(scope, parentScope) {
|
||
|
|
const value = !!this.evaluate(scope);
|
||
|
|
const mustMount = !this.value && value;
|
||
|
|
const mustUnmount = this.value && !value;
|
||
|
|
const mount = () => {
|
||
|
|
const pristine = this.node.cloneNode();
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(pristine, this.placeholder);
|
||
|
|
this.template = this.template.clone();
|
||
|
|
this.template.mount(pristine, scope, parentScope);
|
||
|
|
};
|
||
|
|
switch (true) {
|
||
|
|
case mustMount:
|
||
|
|
mount();
|
||
|
|
break;
|
||
|
|
case mustUnmount:
|
||
|
|
this.unmount(scope);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
if (value) this.template.update(scope, parentScope);
|
||
|
|
}
|
||
|
|
this.value = value;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
unmount(scope, parentScope) {
|
||
|
|
this.template.unmount(scope, parentScope, true);
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function create$5(node, _ref3) {
|
||
|
|
let {
|
||
|
|
evaluate,
|
||
|
|
template
|
||
|
|
} = _ref3;
|
||
|
|
const placeholder = document.createTextNode('');
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(placeholder, node);
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.removeChild)(node);
|
||
|
|
return Object.assign({}, IfBinding, {
|
||
|
|
node,
|
||
|
|
evaluate,
|
||
|
|
placeholder,
|
||
|
|
template: template.createDOM(node)
|
||
|
|
});
|
||
|
|
}
|
||
|
|
const ElementProto = typeof Element === 'undefined' ? {} : Element.prototype;
|
||
|
|
const isNativeHtmlProperty = (0,_util_misc_js__WEBPACK_IMPORTED_MODULE_5__.memoize)(name => ElementProto.hasOwnProperty(name)); // eslint-disable-line
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Add all the attributes provided
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @param {Object} attributes - object containing the attributes names and values
|
||
|
|
* @returns {undefined} sorry it's a void function :(
|
||
|
|
*/
|
||
|
|
function setAllAttributes(node, attributes) {
|
||
|
|
Object.entries(attributes).forEach(_ref4 => {
|
||
|
|
let [name, value] = _ref4;
|
||
|
|
return attributeExpression(node, {
|
||
|
|
name
|
||
|
|
}, value);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Remove all the attributes provided
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @param {Object} newAttributes - object containing all the new attribute names
|
||
|
|
* @param {Object} oldAttributes - object containing all the old attribute names
|
||
|
|
* @returns {undefined} sorry it's a void function :(
|
||
|
|
*/
|
||
|
|
function removeAllAttributes(node, newAttributes, oldAttributes) {
|
||
|
|
const newKeys = newAttributes ? Object.keys(newAttributes) : [];
|
||
|
|
Object.keys(oldAttributes).filter(name => !newKeys.includes(name)).forEach(attribute => node.removeAttribute(attribute));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check whether the attribute value can be rendered
|
||
|
|
* @param {*} value - expression value
|
||
|
|
* @returns {boolean} true if we can render this attribute value
|
||
|
|
*/
|
||
|
|
function canRenderAttribute(value) {
|
||
|
|
return value === true || ['string', 'number'].includes(typeof value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check whether the attribute should be removed
|
||
|
|
* @param {*} value - expression value
|
||
|
|
* @returns {boolean} boolean - true if the attribute can be removed}
|
||
|
|
*/
|
||
|
|
function shouldRemoveAttribute(value) {
|
||
|
|
return !value && value !== 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This methods handles the DOM attributes updates
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @param {Object} expression - expression object
|
||
|
|
* @param {string} expression.name - attribute name
|
||
|
|
* @param {*} value - new expression value
|
||
|
|
* @param {*} oldValue - the old expression cached value
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function attributeExpression(node, _ref5, value, oldValue) {
|
||
|
|
let {
|
||
|
|
name
|
||
|
|
} = _ref5;
|
||
|
|
// is it a spread operator? {...attributes}
|
||
|
|
if (!name) {
|
||
|
|
if (oldValue) {
|
||
|
|
// remove all the old attributes
|
||
|
|
removeAllAttributes(node, value, oldValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
// is the value still truthy?
|
||
|
|
if (value) {
|
||
|
|
setAllAttributes(node, value);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// handle boolean attributes
|
||
|
|
if (!isNativeHtmlProperty(name) && ((0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isBoolean)(value) || (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isObject)(value) || (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isFunction)(value))) {
|
||
|
|
node[name] = value;
|
||
|
|
}
|
||
|
|
if (shouldRemoveAttribute(value)) {
|
||
|
|
node.removeAttribute(name);
|
||
|
|
} else if (canRenderAttribute(value)) {
|
||
|
|
node.setAttribute(name, normalizeValue(name, value));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the value as string
|
||
|
|
* @param {string} name - attribute name
|
||
|
|
* @param {*} value - user input value
|
||
|
|
* @returns {string} input value as string
|
||
|
|
*/
|
||
|
|
function normalizeValue(name, value) {
|
||
|
|
// be sure that expressions like selected={ true } will be always rendered as selected='selected'
|
||
|
|
return value === true ? name : value;
|
||
|
|
}
|
||
|
|
const RE_EVENTS_PREFIX = /^on/;
|
||
|
|
const getCallbackAndOptions = value => Array.isArray(value) ? value : [value, false];
|
||
|
|
|
||
|
|
// see also https://medium.com/@WebReflection/dom-handleevent-a-cross-platform-standard-since-year-2000-5bf17287fd38
|
||
|
|
const EventListener = {
|
||
|
|
handleEvent(event) {
|
||
|
|
this[event.type](event);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
const ListenersWeakMap = new WeakMap();
|
||
|
|
const createListener = node => {
|
||
|
|
const listener = Object.create(EventListener);
|
||
|
|
ListenersWeakMap.set(node, listener);
|
||
|
|
return listener;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set a new event listener
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @param {Object} expression - expression object
|
||
|
|
* @param {string} expression.name - event name
|
||
|
|
* @param {*} value - new expression value
|
||
|
|
* @returns {value} the callback just received
|
||
|
|
*/
|
||
|
|
function eventExpression(node, _ref6, value) {
|
||
|
|
let {
|
||
|
|
name
|
||
|
|
} = _ref6;
|
||
|
|
const normalizedEventName = name.replace(RE_EVENTS_PREFIX, '');
|
||
|
|
const eventListener = ListenersWeakMap.get(node) || createListener(node);
|
||
|
|
const [callback, options] = getCallbackAndOptions(value);
|
||
|
|
const handler = eventListener[normalizedEventName];
|
||
|
|
const mustRemoveEvent = handler && !callback;
|
||
|
|
const mustAddEvent = callback && !handler;
|
||
|
|
if (mustRemoveEvent) {
|
||
|
|
node.removeEventListener(normalizedEventName, eventListener);
|
||
|
|
}
|
||
|
|
if (mustAddEvent) {
|
||
|
|
node.addEventListener(normalizedEventName, eventListener, options);
|
||
|
|
}
|
||
|
|
eventListener[normalizedEventName] = callback;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Normalize the user value in order to render a empty string in case of falsy values
|
||
|
|
* @param {*} value - user input value
|
||
|
|
* @returns {string} hopefully a string
|
||
|
|
*/
|
||
|
|
function normalizeStringValue(value) {
|
||
|
|
return (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isNil)(value) ? '' : value;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the the target text node to update or create one from of a comment node
|
||
|
|
* @param {HTMLElement} node - any html element containing childNodes
|
||
|
|
* @param {number} childNodeIndex - index of the text node in the childNodes list
|
||
|
|
* @returns {Text} the text node to update
|
||
|
|
*/
|
||
|
|
const getTextNode = (node, childNodeIndex) => {
|
||
|
|
const target = node.childNodes[childNodeIndex];
|
||
|
|
if (target.nodeType === Node.COMMENT_NODE) {
|
||
|
|
const textNode = document.createTextNode('');
|
||
|
|
node.replaceChild(textNode, target);
|
||
|
|
return textNode;
|
||
|
|
}
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This methods handles a simple text expression update
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @param {Object} data - expression object
|
||
|
|
* @param {*} value - new expression value
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function textExpression(node, data, value) {
|
||
|
|
node.data = normalizeStringValue(value);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This methods handles the input fileds value updates
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @param {Object} expression - expression object
|
||
|
|
* @param {*} value - new expression value
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function valueExpression(node, expression, value) {
|
||
|
|
node.value = normalizeStringValue(value);
|
||
|
|
}
|
||
|
|
const expressions = {
|
||
|
|
[_util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.ATTRIBUTE]: attributeExpression,
|
||
|
|
[_util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.EVENT]: eventExpression,
|
||
|
|
[_util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.TEXT]: textExpression,
|
||
|
|
[_util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.VALUE]: valueExpression
|
||
|
|
};
|
||
|
|
const Expression = {
|
||
|
|
// Static props
|
||
|
|
// node: null,
|
||
|
|
// value: null,
|
||
|
|
|
||
|
|
// API methods
|
||
|
|
/**
|
||
|
|
* Mount the expression evaluating its initial value
|
||
|
|
* @param {*} scope - argument passed to the expression to evaluate its current values
|
||
|
|
* @returns {Expression} self
|
||
|
|
*/
|
||
|
|
mount(scope) {
|
||
|
|
// hopefully a pure function
|
||
|
|
this.value = this.evaluate(scope);
|
||
|
|
|
||
|
|
// IO() DOM updates
|
||
|
|
apply(this, this.value);
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Update the expression if its value changed
|
||
|
|
* @param {*} scope - argument passed to the expression to evaluate its current values
|
||
|
|
* @returns {Expression} self
|
||
|
|
*/
|
||
|
|
update(scope) {
|
||
|
|
// pure function
|
||
|
|
const value = this.evaluate(scope);
|
||
|
|
if (this.value !== value) {
|
||
|
|
// IO() DOM updates
|
||
|
|
apply(this, value);
|
||
|
|
this.value = value;
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Expression teardown method
|
||
|
|
* @returns {Expression} self
|
||
|
|
*/
|
||
|
|
unmount() {
|
||
|
|
// unmount only the event handling expressions
|
||
|
|
if (this.type === _util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.EVENT) apply(this, null);
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* IO() function to handle the DOM updates
|
||
|
|
* @param {Expression} expression - expression object
|
||
|
|
* @param {*} value - current expression value
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function apply(expression, value) {
|
||
|
|
return expressions[expression.type](expression.node, expression, value, expression.value);
|
||
|
|
}
|
||
|
|
function create$4(node, data) {
|
||
|
|
return Object.assign({}, Expression, data, {
|
||
|
|
node: data.type === _util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.TEXT ? getTextNode(node, data.childNodeIndex) : node
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a flat object having as keys a list of methods that if dispatched will propagate
|
||
|
|
* on the whole collection
|
||
|
|
* @param {Array} collection - collection to iterate
|
||
|
|
* @param {Array<string>} methods - methods to execute on each item of the collection
|
||
|
|
* @param {*} context - context returned by the new methods created
|
||
|
|
* @returns {Object} a new object to simplify the the nested methods dispatching
|
||
|
|
*/
|
||
|
|
function flattenCollectionMethods(collection, methods, context) {
|
||
|
|
return methods.reduce((acc, method) => {
|
||
|
|
return Object.assign({}, acc, {
|
||
|
|
[method]: scope => {
|
||
|
|
return collection.map(item => item[method](scope)) && context;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
function create$3(node, _ref7) {
|
||
|
|
let {
|
||
|
|
expressions
|
||
|
|
} = _ref7;
|
||
|
|
return Object.assign({}, flattenCollectionMethods(expressions.map(expression => create$4(node, expression)), ['mount', 'update', 'unmount']));
|
||
|
|
}
|
||
|
|
function extendParentScope(attributes, scope, parentScope) {
|
||
|
|
if (!attributes || !attributes.length) return parentScope;
|
||
|
|
const expressions = attributes.map(attr => Object.assign({}, attr, {
|
||
|
|
value: attr.evaluate(scope)
|
||
|
|
}));
|
||
|
|
return Object.assign(Object.create(parentScope || null), (0,_util_misc_js__WEBPACK_IMPORTED_MODULE_5__.evaluateAttributeExpressions)(expressions));
|
||
|
|
}
|
||
|
|
|
||
|
|
// this function is only meant to fix an edge case
|
||
|
|
// https://github.com/riot/riot/issues/2842
|
||
|
|
const getRealParent = (scope, parentScope) => scope[_util_constants_js__WEBPACK_IMPORTED_MODULE_6__.PARENT_KEY_SYMBOL] || parentScope;
|
||
|
|
const SlotBinding = {
|
||
|
|
// dynamic binding properties
|
||
|
|
// node: null,
|
||
|
|
// name: null,
|
||
|
|
attributes: [],
|
||
|
|
// template: null,
|
||
|
|
|
||
|
|
getTemplateScope(scope, parentScope) {
|
||
|
|
return extendParentScope(this.attributes, scope, parentScope);
|
||
|
|
},
|
||
|
|
// API methods
|
||
|
|
mount(scope, parentScope) {
|
||
|
|
const templateData = scope.slots ? scope.slots.find(_ref8 => {
|
||
|
|
let {
|
||
|
|
id
|
||
|
|
} = _ref8;
|
||
|
|
return id === this.name;
|
||
|
|
}) : false;
|
||
|
|
const {
|
||
|
|
parentNode
|
||
|
|
} = this.node;
|
||
|
|
const realParent = getRealParent(scope, parentScope);
|
||
|
|
this.template = templateData && create(templateData.html, templateData.bindings).createDOM(parentNode);
|
||
|
|
if (this.template) {
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.cleanNode)(this.node);
|
||
|
|
this.template.mount(this.node, this.getTemplateScope(scope, realParent), realParent);
|
||
|
|
this.template.children = Array.from(this.node.childNodes);
|
||
|
|
}
|
||
|
|
moveSlotInnerContent(this.node);
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.removeChild)(this.node);
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
update(scope, parentScope) {
|
||
|
|
if (this.template) {
|
||
|
|
const realParent = getRealParent(scope, parentScope);
|
||
|
|
this.template.update(this.getTemplateScope(scope, realParent), realParent);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
unmount(scope, parentScope, mustRemoveRoot) {
|
||
|
|
if (this.template) {
|
||
|
|
this.template.unmount(this.getTemplateScope(scope, parentScope), null, mustRemoveRoot);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Move the inner content of the slots outside of them
|
||
|
|
* @param {HTMLElement} slot - slot node
|
||
|
|
* @returns {undefined} it's a void method ¯\_(ツ)_/¯
|
||
|
|
*/
|
||
|
|
function moveSlotInnerContent(slot) {
|
||
|
|
const child = slot && slot.firstChild;
|
||
|
|
if (!child) return;
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.insertBefore)(child, slot);
|
||
|
|
moveSlotInnerContent(slot);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a single slot binding
|
||
|
|
* @param {HTMLElement} node - slot node
|
||
|
|
* @param {string} name - slot id
|
||
|
|
* @param {AttributeExpressionData[]} attributes - slot attributes
|
||
|
|
* @returns {Object} Slot binding object
|
||
|
|
*/
|
||
|
|
function createSlot(node, _ref9) {
|
||
|
|
let {
|
||
|
|
name,
|
||
|
|
attributes
|
||
|
|
} = _ref9;
|
||
|
|
return Object.assign({}, SlotBinding, {
|
||
|
|
attributes,
|
||
|
|
node,
|
||
|
|
name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a new tag object if it was registered before, otherwise fallback to the simple
|
||
|
|
* template chunk
|
||
|
|
* @param {Function} component - component factory function
|
||
|
|
* @param {Array<Object>} slots - array containing the slots markup
|
||
|
|
* @param {Array} attributes - dynamic attributes that will be received by the tag element
|
||
|
|
* @returns {TagImplementation|TemplateChunk} a tag implementation or a template chunk as fallback
|
||
|
|
*/
|
||
|
|
function getTag(component, slots, attributes) {
|
||
|
|
if (slots === void 0) {
|
||
|
|
slots = [];
|
||
|
|
}
|
||
|
|
if (attributes === void 0) {
|
||
|
|
attributes = [];
|
||
|
|
}
|
||
|
|
// if this tag was registered before we will return its implementation
|
||
|
|
if (component) {
|
||
|
|
return component({
|
||
|
|
slots,
|
||
|
|
attributes
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// otherwise we return a template chunk
|
||
|
|
return create(slotsToMarkup(slots), [...slotBindings(slots), {
|
||
|
|
// the attributes should be registered as binding
|
||
|
|
// if we fallback to a normal template chunk
|
||
|
|
expressions: attributes.map(attr => {
|
||
|
|
return Object.assign({
|
||
|
|
type: _util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.ATTRIBUTE
|
||
|
|
}, attr);
|
||
|
|
})
|
||
|
|
}]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Merge all the slots bindings into a single array
|
||
|
|
* @param {Array<Object>} slots - slots collection
|
||
|
|
* @returns {Array<Bindings>} flatten bindings array
|
||
|
|
*/
|
||
|
|
function slotBindings(slots) {
|
||
|
|
return slots.reduce((acc, _ref10) => {
|
||
|
|
let {
|
||
|
|
bindings
|
||
|
|
} = _ref10;
|
||
|
|
return acc.concat(bindings);
|
||
|
|
}, []);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Merge all the slots together in a single markup string
|
||
|
|
* @param {Array<Object>} slots - slots collection
|
||
|
|
* @returns {string} markup of all the slots in a single string
|
||
|
|
*/
|
||
|
|
function slotsToMarkup(slots) {
|
||
|
|
return slots.reduce((acc, slot) => {
|
||
|
|
return acc + slot.html;
|
||
|
|
}, '');
|
||
|
|
}
|
||
|
|
const TagBinding = {
|
||
|
|
// dynamic binding properties
|
||
|
|
// node: null,
|
||
|
|
// evaluate: null,
|
||
|
|
// name: null,
|
||
|
|
// slots: null,
|
||
|
|
// tag: null,
|
||
|
|
// attributes: null,
|
||
|
|
// getComponent: null,
|
||
|
|
|
||
|
|
mount(scope) {
|
||
|
|
return this.update(scope);
|
||
|
|
},
|
||
|
|
update(scope, parentScope) {
|
||
|
|
const name = this.evaluate(scope);
|
||
|
|
|
||
|
|
// simple update
|
||
|
|
if (name && name === this.name) {
|
||
|
|
this.tag.update(scope);
|
||
|
|
} else {
|
||
|
|
// unmount the old tag if it exists
|
||
|
|
this.unmount(scope, parentScope, true);
|
||
|
|
|
||
|
|
// mount the new tag
|
||
|
|
this.name = name;
|
||
|
|
this.tag = getTag(this.getComponent(name), this.slots, this.attributes);
|
||
|
|
this.tag.mount(this.node, scope);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
unmount(scope, parentScope, keepRootTag) {
|
||
|
|
if (this.tag) {
|
||
|
|
// keep the root tag
|
||
|
|
this.tag.unmount(keepRootTag);
|
||
|
|
}
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function create$2(node, _ref11) {
|
||
|
|
let {
|
||
|
|
evaluate,
|
||
|
|
getComponent,
|
||
|
|
slots,
|
||
|
|
attributes
|
||
|
|
} = _ref11;
|
||
|
|
return Object.assign({}, TagBinding, {
|
||
|
|
node,
|
||
|
|
evaluate,
|
||
|
|
slots,
|
||
|
|
attributes,
|
||
|
|
getComponent
|
||
|
|
});
|
||
|
|
}
|
||
|
|
const bindings = {
|
||
|
|
[_util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__.IF]: create$5,
|
||
|
|
[_util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__.SIMPLE]: create$3,
|
||
|
|
[_util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__.EACH]: create$6,
|
||
|
|
[_util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__.TAG]: create$2,
|
||
|
|
[_util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__.SLOT]: createSlot
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Text expressions in a template tag will get childNodeIndex value normalized
|
||
|
|
* depending on the position of the <template> tag offset
|
||
|
|
* @param {Expression[]} expressions - riot expressions array
|
||
|
|
* @param {number} textExpressionsOffset - offset of the <template> tag
|
||
|
|
* @returns {Expression[]} expressions containing the text expressions normalized
|
||
|
|
*/
|
||
|
|
function fixTextExpressionsOffset(expressions, textExpressionsOffset) {
|
||
|
|
return expressions.map(e => e.type === _util_expression_types_js__WEBPACK_IMPORTED_MODULE_1__.TEXT ? Object.assign({}, e, {
|
||
|
|
childNodeIndex: e.childNodeIndex + textExpressionsOffset
|
||
|
|
}) : e);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Bind a new expression object to a DOM node
|
||
|
|
* @param {HTMLElement} root - DOM node where to bind the expression
|
||
|
|
* @param {TagBindingData} binding - binding data
|
||
|
|
* @param {number|null} templateTagOffset - if it's defined we need to fix the text expressions childNodeIndex offset
|
||
|
|
* @returns {Binding} Binding object
|
||
|
|
*/
|
||
|
|
function create$1(root, binding, templateTagOffset) {
|
||
|
|
const {
|
||
|
|
selector,
|
||
|
|
type,
|
||
|
|
redundantAttribute,
|
||
|
|
expressions
|
||
|
|
} = binding;
|
||
|
|
// find the node to apply the bindings
|
||
|
|
const node = selector ? root.querySelector(selector) : root;
|
||
|
|
|
||
|
|
// remove eventually additional attributes created only to select this node
|
||
|
|
if (redundantAttribute) node.removeAttribute(redundantAttribute);
|
||
|
|
const bindingExpressions = expressions || [];
|
||
|
|
|
||
|
|
// init the binding
|
||
|
|
return (bindings[type] || bindings[_util_binding_types_js__WEBPACK_IMPORTED_MODULE_0__.SIMPLE])(node, Object.assign({}, binding, {
|
||
|
|
expressions: templateTagOffset && !selector ? fixTextExpressionsOffset(bindingExpressions, templateTagOffset) : bindingExpressions
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
// in this case a simple innerHTML is enough
|
||
|
|
function createHTMLTree(html, root) {
|
||
|
|
const template = (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isTemplate)(root) ? root : document.createElement('template');
|
||
|
|
template.innerHTML = html;
|
||
|
|
return template.content;
|
||
|
|
}
|
||
|
|
|
||
|
|
// for svg nodes we need a bit more work
|
||
|
|
function createSVGTree(html, container) {
|
||
|
|
// create the SVGNode
|
||
|
|
const svgNode = container.ownerDocument.importNode(new window.DOMParser().parseFromString(`<svg xmlns="http://www.w3.org/2000/svg">${html}</svg>`, 'application/xml').documentElement, true);
|
||
|
|
return svgNode;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the DOM that will be injected
|
||
|
|
* @param {Object} root - DOM node to find out the context where the fragment will be created
|
||
|
|
* @param {string} html - DOM to create as string
|
||
|
|
* @returns {HTMLDocumentFragment|HTMLElement} a new html fragment
|
||
|
|
*/
|
||
|
|
function createDOMTree(root, html) {
|
||
|
|
if ((0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isSvg)(root)) return createSVGTree(html, root);
|
||
|
|
return createHTMLTree(html, root);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Inject the DOM tree into a target node
|
||
|
|
* @param {HTMLElement} el - target element
|
||
|
|
* @param {DocumentFragment|SVGElement} dom - dom tree to inject
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function injectDOM(el, dom) {
|
||
|
|
switch (true) {
|
||
|
|
case (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isSvg)(el):
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.moveChildren)(dom, el);
|
||
|
|
break;
|
||
|
|
case (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isTemplate)(el):
|
||
|
|
el.parentNode.replaceChild(dom, el);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
el.appendChild(dom);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the Template DOM skeleton
|
||
|
|
* @param {HTMLElement} el - root node where the DOM will be injected
|
||
|
|
* @param {string|HTMLElement} html - HTML markup or HTMLElement that will be injected into the root node
|
||
|
|
* @returns {?DocumentFragment} fragment that will be injected into the root node
|
||
|
|
*/
|
||
|
|
function createTemplateDOM(el, html) {
|
||
|
|
return html && (typeof html === 'string' ? createDOMTree(el, html) : html);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the offset of the <template> tag
|
||
|
|
* @param {HTMLElement} parentNode - template tag parent node
|
||
|
|
* @param {HTMLElement} el - the template tag we want to render
|
||
|
|
* @param {Object} meta - meta properties needed to handle the <template> tags in loops
|
||
|
|
* @returns {number} offset of the <template> tag calculated from its siblings DOM nodes
|
||
|
|
*/
|
||
|
|
function getTemplateTagOffset(parentNode, el, meta) {
|
||
|
|
const siblings = Array.from(parentNode.childNodes);
|
||
|
|
return Math.max(siblings.indexOf(el), siblings.indexOf(meta.head) + 1, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Template Chunk model
|
||
|
|
* @type {Object}
|
||
|
|
*/
|
||
|
|
const TemplateChunk = {
|
||
|
|
// Static props
|
||
|
|
// bindings: null,
|
||
|
|
// bindingsData: null,
|
||
|
|
// html: null,
|
||
|
|
// isTemplateTag: false,
|
||
|
|
// fragment: null,
|
||
|
|
// children: null,
|
||
|
|
// dom: null,
|
||
|
|
// el: null,
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create the template DOM structure that will be cloned on each mount
|
||
|
|
* @param {HTMLElement} el - the root node
|
||
|
|
* @returns {TemplateChunk} self
|
||
|
|
*/
|
||
|
|
createDOM(el) {
|
||
|
|
// make sure that the DOM gets created before cloning the template
|
||
|
|
this.dom = this.dom || createTemplateDOM(el, this.html) || document.createDocumentFragment();
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
// API methods
|
||
|
|
/**
|
||
|
|
* Attach the template to a DOM node
|
||
|
|
* @param {HTMLElement} el - target DOM node
|
||
|
|
* @param {*} scope - template data
|
||
|
|
* @param {*} parentScope - scope of the parent template tag
|
||
|
|
* @param {Object} meta - meta properties needed to handle the <template> tags in loops
|
||
|
|
* @returns {TemplateChunk} self
|
||
|
|
*/
|
||
|
|
mount(el, scope, parentScope, meta) {
|
||
|
|
if (meta === void 0) {
|
||
|
|
meta = {};
|
||
|
|
}
|
||
|
|
if (!el) (0,_util_misc_js__WEBPACK_IMPORTED_MODULE_5__.panic)('Please provide DOM node to mount properly your template');
|
||
|
|
if (this.el) this.unmount(scope);
|
||
|
|
|
||
|
|
// <template> tags require a bit more work
|
||
|
|
// the template fragment might be already created via meta outside of this call
|
||
|
|
const {
|
||
|
|
fragment,
|
||
|
|
children,
|
||
|
|
avoidDOMInjection
|
||
|
|
} = meta;
|
||
|
|
// <template> bindings of course can not have a root element
|
||
|
|
// so we check the parent node to set the query selector bindings
|
||
|
|
const {
|
||
|
|
parentNode
|
||
|
|
} = children ? children[0] : el;
|
||
|
|
const isTemplateTag = (0,_util_checks_js__WEBPACK_IMPORTED_MODULE_4__.isTemplate)(el);
|
||
|
|
const templateTagOffset = isTemplateTag ? getTemplateTagOffset(parentNode, el, meta) : null;
|
||
|
|
|
||
|
|
// create the DOM if it wasn't created before
|
||
|
|
this.createDOM(el);
|
||
|
|
|
||
|
|
// create the DOM of this template cloning the original DOM structure stored in this instance
|
||
|
|
// notice that if a documentFragment was passed (via meta) we will use it instead
|
||
|
|
const cloneNode = fragment || this.dom.cloneNode(true);
|
||
|
|
|
||
|
|
// store root node
|
||
|
|
// notice that for template tags the root note will be the parent tag
|
||
|
|
this.el = isTemplateTag ? parentNode : el;
|
||
|
|
|
||
|
|
// create the children array only for the <template> fragments
|
||
|
|
this.children = isTemplateTag ? children || Array.from(cloneNode.childNodes) : null;
|
||
|
|
|
||
|
|
// inject the DOM into the el only if a fragment is available
|
||
|
|
if (!avoidDOMInjection && cloneNode) injectDOM(el, cloneNode);
|
||
|
|
|
||
|
|
// create the bindings
|
||
|
|
this.bindings = this.bindingsData.map(binding => create$1(this.el, binding, templateTagOffset));
|
||
|
|
this.bindings.forEach(b => b.mount(scope, parentScope));
|
||
|
|
|
||
|
|
// store the template meta properties
|
||
|
|
this.meta = meta;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Update the template with fresh data
|
||
|
|
* @param {*} scope - template data
|
||
|
|
* @param {*} parentScope - scope of the parent template tag
|
||
|
|
* @returns {TemplateChunk} self
|
||
|
|
*/
|
||
|
|
update(scope, parentScope) {
|
||
|
|
this.bindings.forEach(b => b.update(scope, parentScope));
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Remove the template from the node where it was initially mounted
|
||
|
|
* @param {*} scope - template data
|
||
|
|
* @param {*} parentScope - scope of the parent template tag
|
||
|
|
* @param {boolean|null} mustRemoveRoot - if true remove the root element,
|
||
|
|
* if false or undefined clean the root tag content, if null don't touch the DOM
|
||
|
|
* @returns {TemplateChunk} self
|
||
|
|
*/
|
||
|
|
unmount(scope, parentScope, mustRemoveRoot) {
|
||
|
|
if (mustRemoveRoot === void 0) {
|
||
|
|
mustRemoveRoot = false;
|
||
|
|
}
|
||
|
|
const el = this.el;
|
||
|
|
if (!el) {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
this.bindings.forEach(b => b.unmount(scope, parentScope, mustRemoveRoot));
|
||
|
|
switch (true) {
|
||
|
|
// pure components should handle the DOM unmount updates by themselves
|
||
|
|
// for mustRemoveRoot === null don't touch the DOM
|
||
|
|
case el[_util_constants_js__WEBPACK_IMPORTED_MODULE_6__.IS_PURE_SYMBOL] || mustRemoveRoot === null:
|
||
|
|
break;
|
||
|
|
|
||
|
|
// if children are declared, clear them
|
||
|
|
// applicable for <template> and <slot/> bindings
|
||
|
|
case Array.isArray(this.children):
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.clearChildren)(this.children);
|
||
|
|
break;
|
||
|
|
|
||
|
|
// clean the node children only
|
||
|
|
case !mustRemoveRoot:
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.cleanNode)(el);
|
||
|
|
break;
|
||
|
|
|
||
|
|
// remove the root node only if the mustRemoveRoot is truly
|
||
|
|
case !!mustRemoveRoot:
|
||
|
|
(0,_util_dom_js__WEBPACK_IMPORTED_MODULE_2__.removeChild)(el);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
this.el = null;
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
/**
|
||
|
|
* Clone the template chunk
|
||
|
|
* @returns {TemplateChunk} a clone of this object resetting the this.el property
|
||
|
|
*/
|
||
|
|
clone() {
|
||
|
|
return Object.assign({}, this, {
|
||
|
|
meta: {},
|
||
|
|
el: null
|
||
|
|
});
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a template chunk wiring also the bindings
|
||
|
|
* @param {string|HTMLElement} html - template string
|
||
|
|
* @param {BindingData[]} bindings - bindings collection
|
||
|
|
* @returns {TemplateChunk} a new TemplateChunk copy
|
||
|
|
*/
|
||
|
|
function create(html, bindings) {
|
||
|
|
if (bindings === void 0) {
|
||
|
|
bindings = [];
|
||
|
|
}
|
||
|
|
return Object.assign({}, TemplateChunk, {
|
||
|
|
html,
|
||
|
|
bindingsData: bindings
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/binding-types.js":
|
||
|
|
/*!**************************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/binding-types.js ***!
|
||
|
|
\**************************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "EACH": () => (/* binding */ EACH),
|
||
|
|
/* harmony export */ "IF": () => (/* binding */ IF),
|
||
|
|
/* harmony export */ "SIMPLE": () => (/* binding */ SIMPLE),
|
||
|
|
/* harmony export */ "SLOT": () => (/* binding */ SLOT),
|
||
|
|
/* harmony export */ "TAG": () => (/* binding */ TAG),
|
||
|
|
/* harmony export */ "default": () => (/* binding */ bindingTypes)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
const EACH = 0;
|
||
|
|
const IF = 1;
|
||
|
|
const SIMPLE = 2;
|
||
|
|
const TAG = 3;
|
||
|
|
const SLOT = 4;
|
||
|
|
const bindingTypes = {
|
||
|
|
EACH,
|
||
|
|
IF,
|
||
|
|
SIMPLE,
|
||
|
|
TAG,
|
||
|
|
SLOT
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/checks.js":
|
||
|
|
/*!*******************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/checks.js ***!
|
||
|
|
\*******************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "checkType": () => (/* binding */ checkType),
|
||
|
|
/* harmony export */ "isBoolean": () => (/* binding */ isBoolean),
|
||
|
|
/* harmony export */ "isFunction": () => (/* binding */ isFunction),
|
||
|
|
/* harmony export */ "isNil": () => (/* binding */ isNil),
|
||
|
|
/* harmony export */ "isObject": () => (/* binding */ isObject),
|
||
|
|
/* harmony export */ "isSvg": () => (/* binding */ isSvg),
|
||
|
|
/* harmony export */ "isTemplate": () => (/* binding */ isTemplate)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
/**
|
||
|
|
* Quick type checking
|
||
|
|
* @param {*} element - anything
|
||
|
|
* @param {string} type - type definition
|
||
|
|
* @returns {boolean} true if the type corresponds
|
||
|
|
*/
|
||
|
|
function checkType(element, type) {
|
||
|
|
return typeof element === type;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check if an element is part of an svg
|
||
|
|
* @param {HTMLElement} el - element to check
|
||
|
|
* @returns {boolean} true if we are in an svg context
|
||
|
|
*/
|
||
|
|
function isSvg(el) {
|
||
|
|
const owner = el.ownerSVGElement;
|
||
|
|
return !!owner || owner === null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check if an element is a template tag
|
||
|
|
* @param {HTMLElement} el - element to check
|
||
|
|
* @returns {boolean} true if it's a <template>
|
||
|
|
*/
|
||
|
|
function isTemplate(el) {
|
||
|
|
return el.tagName.toLowerCase() === 'template';
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check that will be passed if its argument is a function
|
||
|
|
* @param {*} value - value to check
|
||
|
|
* @returns {boolean} - true if the value is a function
|
||
|
|
*/
|
||
|
|
function isFunction(value) {
|
||
|
|
return checkType(value, 'function');
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check if a value is a Boolean
|
||
|
|
* @param {*} value - anything
|
||
|
|
* @returns {boolean} true only for the value is a boolean
|
||
|
|
*/
|
||
|
|
function isBoolean(value) {
|
||
|
|
return checkType(value, 'boolean');
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check if a value is an Object
|
||
|
|
* @param {*} value - anything
|
||
|
|
* @returns {boolean} true only for the value is an object
|
||
|
|
*/
|
||
|
|
function isObject(value) {
|
||
|
|
return !isNil(value) && value.constructor === Object;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check if a value is null or undefined
|
||
|
|
* @param {*} value - anything
|
||
|
|
* @returns {boolean} true only for the 'undefined' and 'null' types
|
||
|
|
*/
|
||
|
|
function isNil(value) {
|
||
|
|
return value === null || value === undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js":
|
||
|
|
/*!**********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/constants.js ***!
|
||
|
|
\**********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "ATTRIBUTES_KEY_SYMBOL": () => (/* binding */ ATTRIBUTES_KEY_SYMBOL),
|
||
|
|
/* harmony export */ "COMPONENTS_IMPLEMENTATION_MAP": () => (/* binding */ COMPONENTS_IMPLEMENTATION_MAP),
|
||
|
|
/* harmony export */ "DOM_COMPONENT_INSTANCE_PROPERTY": () => (/* binding */ DOM_COMPONENT_INSTANCE_PROPERTY),
|
||
|
|
/* harmony export */ "IS_COMPONENT_UPDATING": () => (/* binding */ IS_COMPONENT_UPDATING),
|
||
|
|
/* harmony export */ "IS_DIRECTIVE": () => (/* binding */ IS_DIRECTIVE),
|
||
|
|
/* harmony export */ "IS_PURE_SYMBOL": () => (/* binding */ IS_PURE_SYMBOL),
|
||
|
|
/* harmony export */ "MOUNT_METHOD_KEY": () => (/* binding */ MOUNT_METHOD_KEY),
|
||
|
|
/* harmony export */ "ON_BEFORE_MOUNT_KEY": () => (/* binding */ ON_BEFORE_MOUNT_KEY),
|
||
|
|
/* harmony export */ "ON_BEFORE_UNMOUNT_KEY": () => (/* binding */ ON_BEFORE_UNMOUNT_KEY),
|
||
|
|
/* harmony export */ "ON_BEFORE_UPDATE_KEY": () => (/* binding */ ON_BEFORE_UPDATE_KEY),
|
||
|
|
/* harmony export */ "ON_MOUNTED_KEY": () => (/* binding */ ON_MOUNTED_KEY),
|
||
|
|
/* harmony export */ "ON_UNMOUNTED_KEY": () => (/* binding */ ON_UNMOUNTED_KEY),
|
||
|
|
/* harmony export */ "ON_UPDATED_KEY": () => (/* binding */ ON_UPDATED_KEY),
|
||
|
|
/* harmony export */ "PARENT_KEY_SYMBOL": () => (/* binding */ PARENT_KEY_SYMBOL),
|
||
|
|
/* harmony export */ "PLUGINS_SET": () => (/* binding */ PLUGINS_SET),
|
||
|
|
/* harmony export */ "PROPS_KEY": () => (/* binding */ PROPS_KEY),
|
||
|
|
/* harmony export */ "ROOT_KEY": () => (/* binding */ ROOT_KEY),
|
||
|
|
/* harmony export */ "SHOULD_UPDATE_KEY": () => (/* binding */ SHOULD_UPDATE_KEY),
|
||
|
|
/* harmony export */ "SLOTS_KEY": () => (/* binding */ SLOTS_KEY),
|
||
|
|
/* harmony export */ "STATE_KEY": () => (/* binding */ STATE_KEY),
|
||
|
|
/* harmony export */ "TEMPLATE_KEY_SYMBOL": () => (/* binding */ TEMPLATE_KEY_SYMBOL),
|
||
|
|
/* harmony export */ "UNMOUNT_METHOD_KEY": () => (/* binding */ UNMOUNT_METHOD_KEY),
|
||
|
|
/* harmony export */ "UPDATE_METHOD_KEY": () => (/* binding */ UPDATE_METHOD_KEY)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
// Riot.js constants that can be used across more modules
|
||
|
|
|
||
|
|
const COMPONENTS_IMPLEMENTATION_MAP = new Map(),
|
||
|
|
DOM_COMPONENT_INSTANCE_PROPERTY = Symbol('riot-component'),
|
||
|
|
PLUGINS_SET = new Set(),
|
||
|
|
IS_DIRECTIVE = 'is',
|
||
|
|
MOUNT_METHOD_KEY = 'mount',
|
||
|
|
UPDATE_METHOD_KEY = 'update',
|
||
|
|
UNMOUNT_METHOD_KEY = 'unmount',
|
||
|
|
SHOULD_UPDATE_KEY = 'shouldUpdate',
|
||
|
|
ON_BEFORE_MOUNT_KEY = 'onBeforeMount',
|
||
|
|
ON_MOUNTED_KEY = 'onMounted',
|
||
|
|
ON_BEFORE_UPDATE_KEY = 'onBeforeUpdate',
|
||
|
|
ON_UPDATED_KEY = 'onUpdated',
|
||
|
|
ON_BEFORE_UNMOUNT_KEY = 'onBeforeUnmount',
|
||
|
|
ON_UNMOUNTED_KEY = 'onUnmounted',
|
||
|
|
PROPS_KEY = 'props',
|
||
|
|
STATE_KEY = 'state',
|
||
|
|
SLOTS_KEY = 'slots',
|
||
|
|
ROOT_KEY = 'root',
|
||
|
|
IS_PURE_SYMBOL = Symbol('pure'),
|
||
|
|
IS_COMPONENT_UPDATING = Symbol('is_updating'),
|
||
|
|
PARENT_KEY_SYMBOL = Symbol('parent'),
|
||
|
|
ATTRIBUTES_KEY_SYMBOL = Symbol('attributes'),
|
||
|
|
TEMPLATE_KEY_SYMBOL = Symbol('template');
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/dom.js":
|
||
|
|
/*!****************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/dom.js ***!
|
||
|
|
\****************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "DOMattributesToObject": () => (/* binding */ DOMattributesToObject),
|
||
|
|
/* harmony export */ "cleanNode": () => (/* binding */ cleanNode),
|
||
|
|
/* harmony export */ "clearChildren": () => (/* binding */ clearChildren),
|
||
|
|
/* harmony export */ "insertBefore": () => (/* binding */ insertBefore),
|
||
|
|
/* harmony export */ "moveChildren": () => (/* binding */ moveChildren),
|
||
|
|
/* harmony export */ "removeChild": () => (/* binding */ removeChild),
|
||
|
|
/* harmony export */ "replaceChild": () => (/* binding */ replaceChild)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _strings_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./strings.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/strings.js");
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get all the element attributes as object
|
||
|
|
* @param {HTMLElement} element - DOM node we want to parse
|
||
|
|
* @returns {Object} all the attributes found as a key value pairs
|
||
|
|
*/
|
||
|
|
function DOMattributesToObject(element) {
|
||
|
|
return Array.from(element.attributes).reduce((acc, attribute) => {
|
||
|
|
acc[(0,_strings_js__WEBPACK_IMPORTED_MODULE_0__.dashToCamelCase)(attribute.name)] = attribute.value;
|
||
|
|
return acc;
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Move all the child nodes from a source tag to another
|
||
|
|
* @param {HTMLElement} source - source node
|
||
|
|
* @param {HTMLElement} target - target node
|
||
|
|
* @returns {undefined} it's a void method ¯\_(ツ)_/¯
|
||
|
|
*/
|
||
|
|
|
||
|
|
// Ignore this helper because it's needed only for svg tags
|
||
|
|
function moveChildren(source, target) {
|
||
|
|
// eslint-disable-next-line fp/no-loops
|
||
|
|
while (source.firstChild) target.appendChild(source.firstChild);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Remove the child nodes from any DOM node
|
||
|
|
* @param {HTMLElement} node - target node
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function cleanNode(node) {
|
||
|
|
// eslint-disable-next-line fp/no-loops
|
||
|
|
while (node.firstChild) node.removeChild(node.firstChild);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Clear multiple children in a node
|
||
|
|
* @param {HTMLElement[]} children - direct children nodes
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
function clearChildren(children) {
|
||
|
|
// eslint-disable-next-line fp/no-loops,fp/no-let
|
||
|
|
for (let i = 0; i < children.length; i++) removeChild(children[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Remove a node
|
||
|
|
* @param {HTMLElement}node - node to remove
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
const removeChild = node => node.remove();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Insert before a node
|
||
|
|
* @param {HTMLElement} newNode - node to insert
|
||
|
|
* @param {HTMLElement} refNode - ref child
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
const insertBefore = (newNode, refNode) => refNode && refNode.parentNode && refNode.parentNode.insertBefore(newNode, refNode);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Replace a node
|
||
|
|
* @param {HTMLElement} newNode - new node to add to the DOM
|
||
|
|
* @param {HTMLElement} replaced - node to replace
|
||
|
|
* @returns {undefined}
|
||
|
|
*/
|
||
|
|
const replaceChild = (newNode, replaced) => replaced && replaced.parentNode && replaced.parentNode.replaceChild(newNode, replaced);
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/expression-types.js":
|
||
|
|
/*!*****************************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/expression-types.js ***!
|
||
|
|
\*****************************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "ATTRIBUTE": () => (/* binding */ ATTRIBUTE),
|
||
|
|
/* harmony export */ "EVENT": () => (/* binding */ EVENT),
|
||
|
|
/* harmony export */ "TEXT": () => (/* binding */ TEXT),
|
||
|
|
/* harmony export */ "VALUE": () => (/* binding */ VALUE),
|
||
|
|
/* harmony export */ "default": () => (/* binding */ expressionTypes)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
const ATTRIBUTE = 0;
|
||
|
|
const EVENT = 1;
|
||
|
|
const TEXT = 2;
|
||
|
|
const VALUE = 3;
|
||
|
|
const expressionTypes = {
|
||
|
|
ATTRIBUTE,
|
||
|
|
EVENT,
|
||
|
|
TEXT,
|
||
|
|
VALUE
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/functions.js":
|
||
|
|
/*!**********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/functions.js ***!
|
||
|
|
\**********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "autobindMethods": () => (/* binding */ autobindMethods),
|
||
|
|
/* harmony export */ "callOrAssign": () => (/* binding */ callOrAssign),
|
||
|
|
/* harmony export */ "noop": () => (/* binding */ noop)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _checks_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./checks.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/checks.js");
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
// does simply nothing
|
||
|
|
function noop() {
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Autobind the methods of a source object to itself
|
||
|
|
* @param {Object} source - probably a riot tag instance
|
||
|
|
* @param {Array<string>} methods - list of the methods to autobind
|
||
|
|
* @returns {Object} the original object received
|
||
|
|
*/
|
||
|
|
function autobindMethods(source, methods) {
|
||
|
|
methods.forEach(method => {
|
||
|
|
source[method] = source[method].bind(source);
|
||
|
|
});
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Call the first argument received only if it's a function otherwise return it as it is
|
||
|
|
* @param {*} source - anything
|
||
|
|
* @returns {*} anything
|
||
|
|
*/
|
||
|
|
function callOrAssign(source) {
|
||
|
|
return (0,_checks_js__WEBPACK_IMPORTED_MODULE_0__.isFunction)(source) ? source.prototype && source.prototype.constructor ? new source() : source() : source;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/misc.js":
|
||
|
|
/*!*****************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/misc.js ***!
|
||
|
|
\*****************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "evaluateAttributeExpressions": () => (/* binding */ evaluateAttributeExpressions),
|
||
|
|
/* harmony export */ "memoize": () => (/* binding */ memoize),
|
||
|
|
/* harmony export */ "panic": () => (/* binding */ panic)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _expression_types_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./expression-types.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/expression-types.js");
|
||
|
|
/* harmony import */ var _strings_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./strings.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/strings.js");
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Throw an error with a descriptive message
|
||
|
|
* @param { string } message - error message
|
||
|
|
* @param { string } cause - optional error cause object
|
||
|
|
* @returns { undefined } hoppla... at this point the program should stop working
|
||
|
|
*/
|
||
|
|
function panic(message, cause) {
|
||
|
|
throw new Error(message, {
|
||
|
|
cause
|
||
|
|
});
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Returns the memoized (cached) function.
|
||
|
|
* // borrowed from https://www.30secondsofcode.org/js/s/memoize
|
||
|
|
* @param {Function} fn - function to memoize
|
||
|
|
* @returns {Function} memoize function
|
||
|
|
*/
|
||
|
|
function memoize(fn) {
|
||
|
|
const cache = new Map();
|
||
|
|
const cached = val => {
|
||
|
|
return cache.has(val) ? cache.get(val) : cache.set(val, fn.call(this, val)) && cache.get(val);
|
||
|
|
};
|
||
|
|
cached.cache = cache;
|
||
|
|
return cached;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Evaluate a list of attribute expressions
|
||
|
|
* @param {Array} attributes - attribute expressions generated by the riot compiler
|
||
|
|
* @returns {Object} key value pairs with the result of the computation
|
||
|
|
*/
|
||
|
|
function evaluateAttributeExpressions(attributes) {
|
||
|
|
return attributes.reduce((acc, attribute) => {
|
||
|
|
const {
|
||
|
|
value,
|
||
|
|
type
|
||
|
|
} = attribute;
|
||
|
|
switch (true) {
|
||
|
|
// spread attribute
|
||
|
|
case !attribute.name && type === _expression_types_js__WEBPACK_IMPORTED_MODULE_0__.ATTRIBUTE:
|
||
|
|
return Object.assign({}, acc, value);
|
||
|
|
// value attribute
|
||
|
|
case type === _expression_types_js__WEBPACK_IMPORTED_MODULE_0__.VALUE:
|
||
|
|
acc.value = attribute.value;
|
||
|
|
break;
|
||
|
|
// normal attributes
|
||
|
|
default:
|
||
|
|
acc[(0,_strings_js__WEBPACK_IMPORTED_MODULE_1__.dashToCamelCase)(attribute.name)] = attribute.value;
|
||
|
|
}
|
||
|
|
return acc;
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/objects.js":
|
||
|
|
/*!********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/objects.js ***!
|
||
|
|
\********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "defineDefaults": () => (/* binding */ defineDefaults),
|
||
|
|
/* harmony export */ "defineProperties": () => (/* binding */ defineProperties),
|
||
|
|
/* harmony export */ "defineProperty": () => (/* binding */ defineProperty)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
/**
|
||
|
|
* Helper function to set an immutable property
|
||
|
|
* @param {Object} source - object where the new property will be set
|
||
|
|
* @param {string} key - object key where the new property will be stored
|
||
|
|
* @param {*} value - value of the new property
|
||
|
|
* @param {Object} options - set the property overriding the default options
|
||
|
|
* @returns {Object} - the original object modified
|
||
|
|
*/
|
||
|
|
function defineProperty(source, key, value, options) {
|
||
|
|
if (options === void 0) {
|
||
|
|
options = {};
|
||
|
|
}
|
||
|
|
/* eslint-disable fp/no-mutating-methods */
|
||
|
|
Object.defineProperty(source, key, Object.assign({
|
||
|
|
value,
|
||
|
|
enumerable: false,
|
||
|
|
writable: false,
|
||
|
|
configurable: true
|
||
|
|
}, options));
|
||
|
|
/* eslint-enable fp/no-mutating-methods */
|
||
|
|
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Define multiple properties on a target object
|
||
|
|
* @param {Object} source - object where the new properties will be set
|
||
|
|
* @param {Object} properties - object containing as key pair the key + value properties
|
||
|
|
* @param {Object} options - set the property overriding the default options
|
||
|
|
* @returns {Object} the original object modified
|
||
|
|
*/
|
||
|
|
function defineProperties(source, properties, options) {
|
||
|
|
Object.entries(properties).forEach(_ref => {
|
||
|
|
let [key, value] = _ref;
|
||
|
|
defineProperty(source, key, value, options);
|
||
|
|
});
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Define default properties if they don't exist on the source object
|
||
|
|
* @param {Object} source - object that will receive the default properties
|
||
|
|
* @param {Object} defaults - object containing additional optional keys
|
||
|
|
* @returns {Object} the original object received enhanced
|
||
|
|
*/
|
||
|
|
function defineDefaults(source, defaults) {
|
||
|
|
Object.entries(defaults).forEach(_ref2 => {
|
||
|
|
let [key, value] = _ref2;
|
||
|
|
if (!source[key]) source[key] = value;
|
||
|
|
});
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/@riotjs/util/strings.js":
|
||
|
|
/*!********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/@riotjs/util/strings.js ***!
|
||
|
|
\********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "camelToDashCase": () => (/* binding */ camelToDashCase),
|
||
|
|
/* harmony export */ "dashToCamelCase": () => (/* binding */ dashToCamelCase)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
/**
|
||
|
|
* Convert a string from camel case to dash-case
|
||
|
|
* @param {string} string - probably a component tag name
|
||
|
|
* @returns {string} component name normalized
|
||
|
|
*/
|
||
|
|
function camelToDashCase(string) {
|
||
|
|
return string.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Convert a string containing dashes to camel case
|
||
|
|
* @param {string} string - input string
|
||
|
|
* @returns {string} my-string -> myString
|
||
|
|
*/
|
||
|
|
function dashToCamelCase(string) {
|
||
|
|
return string.replace(/-(\w)/g, (_, c) => c.toUpperCase());
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/bianco.attr/index.next.js":
|
||
|
|
/*!**********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/bianco.attr/index.next.js ***!
|
||
|
|
\**********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "get": () => (/* binding */ get),
|
||
|
|
/* harmony export */ "set": () => (/* binding */ set)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _bianco_dom_to_array_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../bianco.dom-to-array/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.dom-to-array/index.next.js");
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Normalize the return values, in case of a single value we avoid to return an array
|
||
|
|
* @param { Array } values - list of values we want to return
|
||
|
|
* @returns { Array|string|boolean } either the whole list of values or the single one found
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
const normalize = values => values.length === 1 ? values[0] : values;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Parse all the nodes received to get/remove/check their attributes
|
||
|
|
* @param { HTMLElement|NodeList|Array } els - DOM node/s to parse
|
||
|
|
* @param { string|Array } name - name or list of attributes
|
||
|
|
* @param { string } method - method that will be used to parse the attributes
|
||
|
|
* @returns { Array|string } result of the parsing in a list or a single value
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
function parseNodes(els, name, method) {
|
||
|
|
const names = typeof name === 'string' ? [name] : name;
|
||
|
|
return normalize((0,_bianco_dom_to_array_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(els).map(el => {
|
||
|
|
return normalize(names.map(n => el[method](n)));
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set any attribute on a single or a list of DOM nodes
|
||
|
|
* @param { HTMLElement|NodeList|Array } els - DOM node/s to parse
|
||
|
|
* @param { string|Object } name - either the name of the attribute to set
|
||
|
|
* or a list of properties as object key - value
|
||
|
|
* @param { string } value - the new value of the attribute (optional)
|
||
|
|
* @returns { HTMLElement|NodeList|Array } the original array of elements passed to this function
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* import { set } from 'bianco.attr'
|
||
|
|
*
|
||
|
|
* const img = document.createElement('img')
|
||
|
|
*
|
||
|
|
* set(img, 'width', 100)
|
||
|
|
*
|
||
|
|
* // or also
|
||
|
|
* set(img, {
|
||
|
|
* width: 300,
|
||
|
|
* height: 300
|
||
|
|
* })
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
function set(els, name, value) {
|
||
|
|
const attrs = typeof name === 'object' ? name : {
|
||
|
|
[name]: value
|
||
|
|
};
|
||
|
|
const props = Object.keys(attrs);
|
||
|
|
(0,_bianco_dom_to_array_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(els).forEach(el => {
|
||
|
|
props.forEach(prop => el.setAttribute(prop, attrs[prop]));
|
||
|
|
});
|
||
|
|
return els;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get any attribute from a single or a list of DOM nodes
|
||
|
|
* @param { HTMLElement|NodeList|Array } els - DOM node/s to parse
|
||
|
|
* @param { string|Array } name - name or list of attributes to get
|
||
|
|
* @returns { Array|string } list of the attributes found
|
||
|
|
*
|
||
|
|
* @example
|
||
|
|
*
|
||
|
|
* import { get } from 'bianco.attr'
|
||
|
|
*
|
||
|
|
* const img = document.createElement('img')
|
||
|
|
*
|
||
|
|
* get(img, 'width') // => '200'
|
||
|
|
*
|
||
|
|
* // or also
|
||
|
|
* get(img, ['width', 'height']) // => ['200', '300']
|
||
|
|
*
|
||
|
|
* // or also
|
||
|
|
* get([img1, img2], ['width', 'height']) // => [['200', '300'], ['500', '200']]
|
||
|
|
*/
|
||
|
|
function get(els, name) {
|
||
|
|
return parseNodes(els, name, 'getAttribute');
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/bianco.dom-to-array/index.next.js":
|
||
|
|
/*!******************************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/bianco.dom-to-array/index.next.js ***!
|
||
|
|
\******************************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (/* binding */ domToArray)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
/**
|
||
|
|
* Converts any DOM node/s to a loopable array
|
||
|
|
* @param { HTMLElement|NodeList } els - single html element or a node list
|
||
|
|
* @returns { Array } always a loopable object
|
||
|
|
*/
|
||
|
|
function domToArray(els) {
|
||
|
|
// can this object be already looped?
|
||
|
|
if (!Array.isArray(els)) {
|
||
|
|
// is it a node list?
|
||
|
|
if (/^\[object (HTMLCollection|NodeList|Object)\]$/.test(Object.prototype.toString.call(els)) && typeof els.length === 'number') return Array.from(els);else
|
||
|
|
// if it's a single node
|
||
|
|
// it will be returned as "array" with one single entry
|
||
|
|
return [els];
|
||
|
|
}
|
||
|
|
// this object could be looped out of the box
|
||
|
|
return els;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/bianco.query/index.next.js":
|
||
|
|
/*!***********************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/bianco.query/index.next.js ***!
|
||
|
|
\***********************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (/* binding */ $)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _bianco_dom_to_array_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../bianco.dom-to-array/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.dom-to-array/index.next.js");
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Simple helper to find DOM nodes returning them as array like loopable object
|
||
|
|
* @param { string|DOMNodeList } selector - either the query or the DOM nodes to arraify
|
||
|
|
* @param { HTMLElement } scope - context defining where the query will search for the DOM nodes
|
||
|
|
* @returns { Array } DOM nodes found as array
|
||
|
|
*/
|
||
|
|
function $(selector, scope) {
|
||
|
|
return (0,_bianco_dom_to_array_index_next_js__WEBPACK_IMPORTED_MODULE_0__["default"])(typeof selector === 'string' ? (scope || document).querySelectorAll(selector) : selector);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/cumpa/index.next.js":
|
||
|
|
/*!****************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/cumpa/index.next.js ***!
|
||
|
|
\****************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (/* binding */ compose)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
/**
|
||
|
|
* Similar to compose but performs from left-to-right function composition.<br/>
|
||
|
|
* {@link https://30secondsofcode.org/function#composeright see also}
|
||
|
|
* @param {...[function]} fns) - list of unary function
|
||
|
|
* @returns {*} result of the computation
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Performs right-to-left function composition.<br/>
|
||
|
|
* Use Array.prototype.reduce() to perform right-to-left function composition.<br/>
|
||
|
|
* The last (rightmost) function can accept one or more arguments; the remaining functions must be unary.<br/>
|
||
|
|
* {@link https://30secondsofcode.org/function#compose original source code}
|
||
|
|
* @param {...[function]} fns) - list of unary function
|
||
|
|
* @returns {*} result of the computation
|
||
|
|
*/
|
||
|
|
function compose() {
|
||
|
|
for (var _len2 = arguments.length, fns = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
||
|
|
fns[_key2] = arguments[_key2];
|
||
|
|
}
|
||
|
|
return fns.reduce((f, g) => function () {
|
||
|
|
return f(g(...arguments));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/node_modules/curri/index.next.js":
|
||
|
|
/*!****************************************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/node_modules/curri/index.next.js ***!
|
||
|
|
\****************************************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "default": () => (/* binding */ curry)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* Riot WIP, @license MIT */
|
||
|
|
/**
|
||
|
|
* Function to curry any javascript method
|
||
|
|
* @param {Function} fn - the target function we want to curry
|
||
|
|
* @param {...[args]} acc - initial arguments
|
||
|
|
* @returns {Function|*} it will return a function until the target function
|
||
|
|
* will receive all of its arguments
|
||
|
|
*/
|
||
|
|
function curry(fn) {
|
||
|
|
for (var _len = arguments.length, acc = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
|
|
acc[_key - 1] = arguments[_key];
|
||
|
|
}
|
||
|
|
return function () {
|
||
|
|
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
||
|
|
args[_key2] = arguments[_key2];
|
||
|
|
}
|
||
|
|
args = [...acc, ...args];
|
||
|
|
return args.length < fn.length ? curry(fn, ...args) : fn(...args);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/riot.js":
|
||
|
|
/*!***************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/riot.js ***!
|
||
|
|
\***************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "__": () => (/* reexport safe */ _api_js__WEBPACK_IMPORTED_MODULE_10__.__),
|
||
|
|
/* harmony export */ "component": () => (/* reexport safe */ _api_component_js__WEBPACK_IMPORTED_MODULE_6__.component),
|
||
|
|
/* harmony export */ "install": () => (/* reexport safe */ _api_install_js__WEBPACK_IMPORTED_MODULE_4__.install),
|
||
|
|
/* harmony export */ "mount": () => (/* reexport safe */ _api_mount_js__WEBPACK_IMPORTED_MODULE_2__.mount),
|
||
|
|
/* harmony export */ "pure": () => (/* reexport safe */ _api_pure_js__WEBPACK_IMPORTED_MODULE_7__.pure),
|
||
|
|
/* harmony export */ "register": () => (/* reexport safe */ _api_register_js__WEBPACK_IMPORTED_MODULE_0__.register),
|
||
|
|
/* harmony export */ "uninstall": () => (/* reexport safe */ _api_uninstall_js__WEBPACK_IMPORTED_MODULE_5__.uninstall),
|
||
|
|
/* harmony export */ "unmount": () => (/* reexport safe */ _api_unmount_js__WEBPACK_IMPORTED_MODULE_3__.unmount),
|
||
|
|
/* harmony export */ "unregister": () => (/* reexport safe */ _api_unregister_js__WEBPACK_IMPORTED_MODULE_1__.unregister),
|
||
|
|
/* harmony export */ "version": () => (/* reexport safe */ _api_version_js__WEBPACK_IMPORTED_MODULE_9__.version),
|
||
|
|
/* harmony export */ "withTypes": () => (/* reexport safe */ _api_with_types_js__WEBPACK_IMPORTED_MODULE_8__.withTypes)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _api_register_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./api/register.js */ "./node_modules/riot/esm/api/register.js");
|
||
|
|
/* harmony import */ var _api_unregister_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./api/unregister.js */ "./node_modules/riot/esm/api/unregister.js");
|
||
|
|
/* harmony import */ var _api_mount_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./api/mount.js */ "./node_modules/riot/esm/api/mount.js");
|
||
|
|
/* harmony import */ var _api_unmount_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./api/unmount.js */ "./node_modules/riot/esm/api/unmount.js");
|
||
|
|
/* harmony import */ var _api_install_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./api/install.js */ "./node_modules/riot/esm/api/install.js");
|
||
|
|
/* harmony import */ var _api_uninstall_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./api/uninstall.js */ "./node_modules/riot/esm/api/uninstall.js");
|
||
|
|
/* harmony import */ var _api_component_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./api/component.js */ "./node_modules/riot/esm/api/component.js");
|
||
|
|
/* harmony import */ var _api_pure_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./api/pure.js */ "./node_modules/riot/esm/api/pure.js");
|
||
|
|
/* harmony import */ var _api_with_types_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./api/with-types.js */ "./node_modules/riot/esm/api/with-types.js");
|
||
|
|
/* harmony import */ var _api_version_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./api/version.js */ "./node_modules/riot/esm/api/version.js");
|
||
|
|
/* harmony import */ var _api_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./api/__.js */ "./node_modules/riot/esm/api/__.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ }),
|
||
|
|
|
||
|
|
/***/ "./node_modules/riot/esm/utils/dom.js":
|
||
|
|
/*!********************************************!*\
|
||
|
|
!*** ./node_modules/riot/esm/utils/dom.js ***!
|
||
|
|
\********************************************/
|
||
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
|
|
||
|
|
"use strict";
|
||
|
|
__webpack_require__.r(__webpack_exports__);
|
||
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
||
|
|
/* harmony export */ "getName": () => (/* binding */ getName)
|
||
|
|
/* harmony export */ });
|
||
|
|
/* harmony import */ var _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/@riotjs/util/constants.js */ "./node_modules/riot/esm/node_modules/@riotjs/util/constants.js");
|
||
|
|
/* harmony import */ var _node_modules_bianco_attr_index_next_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/bianco.attr/index.next.js */ "./node_modules/riot/esm/node_modules/bianco.attr/index.next.js");
|
||
|
|
/* Riot v7.1.0, @license MIT */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the tag name of any DOM node
|
||
|
|
* @param {HTMLElement} element - DOM node we want to inspect
|
||
|
|
* @returns {string} name to identify this dom node in riot
|
||
|
|
*/
|
||
|
|
function getName(element) {
|
||
|
|
return (0,_node_modules_bianco_attr_index_next_js__WEBPACK_IMPORTED_MODULE_0__.get)(element, _node_modules_riotjs_util_constants_js__WEBPACK_IMPORTED_MODULE_1__.IS_DIRECTIVE) || element.tagName.toLowerCase();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/***/ })
|
||
|
|
|
||
|
|
/******/ });
|
||
|
|
/************************************************************************/
|
||
|
|
/******/ // The module cache
|
||
|
|
/******/ var __webpack_module_cache__ = {};
|
||
|
|
/******/
|
||
|
|
/******/ // The require function
|
||
|
|
/******/ function __webpack_require__(moduleId) {
|
||
|
|
/******/ // Check if module is in cache
|
||
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
||
|
|
/******/ if (cachedModule !== undefined) {
|
||
|
|
/******/ return cachedModule.exports;
|
||
|
|
/******/ }
|
||
|
|
/******/ // Create a new module (and put it into the cache)
|
||
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
||
|
|
/******/ // no module.id needed
|
||
|
|
/******/ // no module.loaded needed
|
||
|
|
/******/ exports: {}
|
||
|
|
/******/ };
|
||
|
|
/******/
|
||
|
|
/******/ // Execute the module function
|
||
|
|
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
|
||
|
|
/******/
|
||
|
|
/******/ // Return the exports of the module
|
||
|
|
/******/ return module.exports;
|
||
|
|
/******/ }
|
||
|
|
/******/
|
||
|
|
/******/ // expose the modules object (__webpack_modules__)
|
||
|
|
/******/ __webpack_require__.m = __webpack_modules__;
|
||
|
|
/******/
|
||
|
|
/************************************************************************/
|
||
|
|
/******/ /* webpack/runtime/chunk loaded */
|
||
|
|
/******/ (() => {
|
||
|
|
/******/ var deferred = [];
|
||
|
|
/******/ __webpack_require__.O = (result, chunkIds, fn, priority) => {
|
||
|
|
/******/ if(chunkIds) {
|
||
|
|
/******/ priority = priority || 0;
|
||
|
|
/******/ for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
|
||
|
|
/******/ deferred[i] = [chunkIds, fn, priority];
|
||
|
|
/******/ return;
|
||
|
|
/******/ }
|
||
|
|
/******/ var notFulfilled = Infinity;
|
||
|
|
/******/ for (var i = 0; i < deferred.length; i++) {
|
||
|
|
/******/ var [chunkIds, fn, priority] = deferred[i];
|
||
|
|
/******/ var fulfilled = true;
|
||
|
|
/******/ for (var j = 0; j < chunkIds.length; j++) {
|
||
|
|
/******/ if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
|
||
|
|
/******/ chunkIds.splice(j--, 1);
|
||
|
|
/******/ } else {
|
||
|
|
/******/ fulfilled = false;
|
||
|
|
/******/ if(priority < notFulfilled) notFulfilled = priority;
|
||
|
|
/******/ }
|
||
|
|
/******/ }
|
||
|
|
/******/ if(fulfilled) {
|
||
|
|
/******/ deferred.splice(i--, 1)
|
||
|
|
/******/ var r = fn();
|
||
|
|
/******/ if (r !== undefined) result = r;
|
||
|
|
/******/ }
|
||
|
|
/******/ }
|
||
|
|
/******/ return result;
|
||
|
|
/******/ };
|
||
|
|
/******/ })();
|
||
|
|
/******/
|
||
|
|
/******/ /* webpack/runtime/compat get default export */
|
||
|
|
/******/ (() => {
|
||
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
||
|
|
/******/ __webpack_require__.n = (module) => {
|
||
|
|
/******/ var getter = module && module.__esModule ?
|
||
|
|
/******/ () => (module['default']) :
|
||
|
|
/******/ () => (module);
|
||
|
|
/******/ __webpack_require__.d(getter, { a: getter });
|
||
|
|
/******/ return getter;
|
||
|
|
/******/ };
|
||
|
|
/******/ })();
|
||
|
|
/******/
|
||
|
|
/******/ /* webpack/runtime/define property getters */
|
||
|
|
/******/ (() => {
|
||
|
|
/******/ // define getter functions for harmony exports
|
||
|
|
/******/ __webpack_require__.d = (exports, definition) => {
|
||
|
|
/******/ for(var key in definition) {
|
||
|
|
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
||
|
|
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
||
|
|
/******/ }
|
||
|
|
/******/ }
|
||
|
|
/******/ };
|
||
|
|
/******/ })();
|
||
|
|
/******/
|
||
|
|
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
||
|
|
/******/ (() => {
|
||
|
|
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
|
||
|
|
/******/ })();
|
||
|
|
/******/
|
||
|
|
/******/ /* webpack/runtime/make namespace object */
|
||
|
|
/******/ (() => {
|
||
|
|
/******/ // define __esModule on exports
|
||
|
|
/******/ __webpack_require__.r = (exports) => {
|
||
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
||
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
||
|
|
/******/ }
|
||
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
|
/******/ };
|
||
|
|
/******/ })();
|
||
|
|
/******/
|
||
|
|
/******/ /* webpack/runtime/jsonp chunk loading */
|
||
|
|
/******/ (() => {
|
||
|
|
/******/ // no baseURI
|
||
|
|
/******/
|
||
|
|
/******/ // object to store loaded and loading chunks
|
||
|
|
/******/ // undefined = chunk not loaded, null = chunk preloaded/prefetched
|
||
|
|
/******/ // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
|
||
|
|
/******/ var installedChunks = {
|
||
|
|
/******/ "/example": 0,
|
||
|
|
/******/ "example": 0
|
||
|
|
/******/ };
|
||
|
|
/******/
|
||
|
|
/******/ // no chunk on demand loading
|
||
|
|
/******/
|
||
|
|
/******/ // no prefetching
|
||
|
|
/******/
|
||
|
|
/******/ // no preloaded
|
||
|
|
/******/
|
||
|
|
/******/ // no HMR
|
||
|
|
/******/
|
||
|
|
/******/ // no HMR manifest
|
||
|
|
/******/
|
||
|
|
/******/ __webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);
|
||
|
|
/******/
|
||
|
|
/******/ // install a JSONP callback for chunk loading
|
||
|
|
/******/ var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
|
||
|
|
/******/ var [chunkIds, moreModules, runtime] = data;
|
||
|
|
/******/ // add "moreModules" to the modules object,
|
||
|
|
/******/ // then flag all "chunkIds" as loaded and fire callback
|
||
|
|
/******/ var moduleId, chunkId, i = 0;
|
||
|
|
/******/ if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
|
||
|
|
/******/ for(moduleId in moreModules) {
|
||
|
|
/******/ if(__webpack_require__.o(moreModules, moduleId)) {
|
||
|
|
/******/ __webpack_require__.m[moduleId] = moreModules[moduleId];
|
||
|
|
/******/ }
|
||
|
|
/******/ }
|
||
|
|
/******/ if(runtime) var result = runtime(__webpack_require__);
|
||
|
|
/******/ }
|
||
|
|
/******/ if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
|
||
|
|
/******/ for(;i < chunkIds.length; i++) {
|
||
|
|
/******/ chunkId = chunkIds[i];
|
||
|
|
/******/ if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
|
||
|
|
/******/ installedChunks[chunkId][0]();
|
||
|
|
/******/ }
|
||
|
|
/******/ installedChunks[chunkId] = 0;
|
||
|
|
/******/ }
|
||
|
|
/******/ return __webpack_require__.O(result);
|
||
|
|
/******/ }
|
||
|
|
/******/
|
||
|
|
/******/ var chunkLoadingGlobal = self["webpackChunk_tiny_components_slider"] = self["webpackChunk_tiny_components_slider"] || [];
|
||
|
|
/******/ chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
|
||
|
|
/******/ chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
|
||
|
|
/******/ })();
|
||
|
|
/******/
|
||
|
|
/************************************************************************/
|
||
|
|
/******/
|
||
|
|
/******/ // startup
|
||
|
|
/******/ // Load entry module and return exports
|
||
|
|
/******/ // This entry module depends on other loaded chunks and execution need to be delayed
|
||
|
|
/******/ __webpack_require__.O(undefined, ["example"], () => (__webpack_require__("./src/example.js")))
|
||
|
|
/******/ var __webpack_exports__ = __webpack_require__.O(undefined, ["example"], () => (__webpack_require__("./src/example.scss")))
|
||
|
|
/******/ __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
|
||
|
|
/******/
|
||
|
|
/******/ })()
|
||
|
|
;
|